You typed man cp in the terminal?

Ok, so I will create 100k memory maps of my file length, and then write each file into the memory map. It says to type in the length of the new mapping, so for a file that is 99.4 mb, do I just type in 99,400,00 for the length of the file?

Well I have the code here in Java:

http://howtodoinjava.com/java-7/nio/...ffer-tutorial/

It makes the memory mapping in baca decimal, so for 99.4 mb it would be 0x5ECB940, then I write a code to do this and I don't think that it will be able to create 100k memory mapped files and copy 100k files into them instantly. That is the same problem I had in Java.

Nothing happens instantly.
It's a finite world.

Never heard of baca decimal.

I suggest you write a more practical program.

what the heck is baca decimal?
You may use the command ls to check the size of a file, in bytes. Or try wc (see man pages for detailed usage).
What is the problem with cp?
Why??? Where is this coming from?

I meant to say hexa decimal but I am going to try a new way. Since all of Linux is already run using virtual memory, my plan is to just copy the same file over and over again 100k times into the same folder. So I put the file into the main directory that the terminal uses. When I type in the code:

For I in {1..100000} ; do cp FILE ~/ ; done

I get the msg that they are both the same file... Is there a way to use the cp command to rename them all different names in the same code somehow? I've tried looking online but it says to use -a and then when I do it still doesn't work. -a is the archive command.

Oh wait just found it: for () do cp file file-$i ; done

Congratulations.

Quite pointless, of course.

see post #27

You didn't mention the problems a 100000 files in a single directory could cause...

I just wanted to update this again: I still have not found any working solution to filling up the virtual memory with one file, I have been trying things posted and checking the virtual memory in use using: free -t Nothing shows up. So I will post my code here, I believe that it isn't working because it is just using the same virtual memory address each time it does a new memory mapping? I looped it 200k times using the for loop but after I check the virtual memory usage using free -t I dont see any swap space being used.


/* For the size of the file. */
#include <sys/stat.h>
/* This contains the mmap calls. */
#include <sys/mman.h>
/* These are for error printing. */
#include <errno.h>
#include <string.h>
#include <stdarg.h>
/* This is for open. */
#include <fcntl.h>
#include <stdio.h>
/* For exit. */
#include <stdlib.h>
/* For the final part of the example. */
#include <ctype.h>

/* "check" checks "test" and prints an error and exits if it is
true. */

static void
check (int test, const char * message, ...)
{
if (test) {
va_list args;
va_start (args, message);
vfprintf (stderr, message, args);
va_end (args);
fprintf (stderr, "\n");
exit (EXIT_FAILURE);
}
}

int main ()
{
/* The file descriptor. */
int fd;
/* Information about the file. */
struct stat s;
int status;
size_t size;
/* The file name to open. */
const char * file_name = "MentalClarity.png";
/* The memory-mapped thing itself. */
const char * mapped[200000];
int i;


/* Open the file for reading. */
fd=open("MentalClarity.png", O_RDWR);
check (fd < 0, "open %s failed: %s", file_name, strerror (errno));


/* Get the size of the file. */
status = fstat (fd, & s);
check (status < 0, "stat %s failed: %s", file_name, strerror (errno));
size = s.st_size;

for (int scount=1;scount<=200000;scount++) {


/* Memory-map the file. */
mapped[scount] = mmap (0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
check (mapped[scount] == MAP_FAILED, "mmap %s failed: %s",
file_name, strerror (errno));

}

return 0;
}

Why should it do anything but what you told it to do? You opened the file, you mapped it.

Nothing else. Each time you call mmap all you do is set the amount - and just set it to the same thing. It was put in your virtual memory map, all 200,000 times...

All you did was use up system time on one system call.

One last thing - once you exited the virtual memory got released.

Perhaps you need to understand what virtual memory really is:
https://en.wikipedia.org/wiki/Virtual_memory

None of what you did requires physical memory (well, maybe 1.5MB for the array and some for the executable). It is all virtual...

Oh I see, so I ran the program and then exited the program, and then the virtual memory disappeared because the program was the only thing that was using it... I'll change the script to allow the program to run continuously after the memory mappings and then test the virtual memory with free -t

It won't change unless something directs the system to access the pages. After that, pages will be dropped to be reused for other pages...

As long as nothing access the pages you won't see any changes.

Oh ok so I need to make the program read each memory mapping continuously and then have the file run until I want it to exit? That way the memory mappings will all stay running right?