Printable View
Hi,
I have a simple quick question:
when i allocate memory for my array let say:
int a[50];
and then only initialize the 35 element in the array:
a[34] = 5;
how much memory will I use. Will all alocated memory be unavailable any more for any other process or just memory location a[34]?
cheers
baxy
There's no simple easy answer - it depends on how you allocate memory, what OS you're using, and so on.
Why do you need to know?
> int a[50];
50 * sizeof(int) gets allocated immediately, and persists until the scope you declared it in disappears.
Your use of individual elements doesn't matter.
Now if you have something like
int large[1000000];
and you assign
large[1000] = 42;
it MAY be the case that large blocks of the array are not located in physical memory all of the time. This is entirely down to the paging strategy of your OS and is outside the scope of your C program.
aha...
so I'm talking about unix OS and i wondering if i for example have this 2D table (array) and i fill just several blocks, can i say that u used only 3 memory locations if onla 3 blocks were filled even though the table is, let say 10000 x 10000 mem locations big
and the reaso why i'm asking is because as i said i have a big table but it is not possible to fill all the positions but only 10000+10000 although the table needs to be 10000x10000. so i'm wondering how much memory am i occupying:
10000+10000
or
10000x10000
Typically the OS will allocate memory a page at a time. A page is typically 4KB, or thereabouts. Until you write to memory, some OSes will just mark the memory as allocated to a process but not actually match it up with physical memory (or swap, or whatever). If you read from it, you'll get garbage since it doesn't map to anything real, but that's OK since reading from unitialized memory isn't well-defined anyway.
Once you write to it, the OS will actually map the page to physical memory. So if you only use a small part of a large array, you're probably not going to use up all the memory. Don't initialize the whole things to 0 first, though, since that will map it to physical locations even if you never use it again (the OS can't see the future or read your mind to know you're never going to see it again).
But this all depends on which specific Unix OS you're talking about. Linux works as I described it, more or less, so you'll get 10000+10000 instead of 10000x10000 (rounded up to page size boundaries). Others may vary.
Perhaps you should implement your own sparse matrix, along one of these themes.
Sparse matrix - Wikipedia, the free encyclopedia
You might only be writing to 1% of the matrix, but if you try and read the remaining 99% (to see if it is zero), then the pages will become mapped and all of a sudden, your memory footprint jumps up to 0.5GB.
Fill in the details about how this array is being declared: outside of any function or inside a function.Quote:
Originally Posted by baxy
If declared inside a function, its runtime memory allocation will be 10000 x 10000 x sizeof(int) as stack frames are not allocated on a piecemeal basis. It's all or nothing.
Albeit, if it's declared outside any function but some elements are assigned to inside a function its runtime memory allocation depends on how many pages of physmem are allocated to it by the kernel.
That's not initialization. That's assignment.Quote:
Originally Posted by baxy
Initialization looks like this:In fact this isn't about memory management either. Your program's code doesn't actually manage the memory here; It's all taken care of for you. This is simply a matter of memory usage.Code:int a[5] = {1,4,9,16,25};
The simple answer is Yes, the remainder of the array remains available until it goes out of scope.Quote:
Originally Posted by baxy