Vfrdtyky

I allocate a big memory , char* test= malloc(10000000); , then I put value on this memory , and do some work for each value.

What I want is , each 1000 index, I want to release all the memory until it.

For ex.

for(long i=0; i<10000000;i++)

   DoSomeWork(test[i]);

   if(i%1000==0)

       releaseMemory(i-1000,i);

How can I do it in c?

I know that free can only free all of my allocate, but I don't want to wait to the end of work the free all the memory.

I want each 1000 works free all the 1000 back

I must to allocate all the memory in the begining of program.

What you want can be achieved by allocating the program in smaller chunks.

You have to adjust your algorithm to handle a bunch of small sub-arrays which you then can release after use.

In this case, it might be useful to allocate the chunks in reversed direction to give the libc the chance to release the freed memory to the underlying OS.

Let me enhance a bit here:

Assume you want an array with 10000000 (10 million) entries. Instead of allocating it as one chunk as depicted in the question, it could be possible to have

#define CHUNKSIZE 10000

#define ENTRYSIZE 8

#define NUM_CHUNKS 1000



void test(void)

{

    void** outer_array = malloc(NUM_CHUNKS * sizeof(void*))

    for (int i = 0; i < NUM_CHUNKS; i++) {

        void * chunk = malloc(CHUNKSIZE * ENTRYSIZE);

        outer_array[NUM_CHUNKS - 1 - i] = chunk;

        // allocate them in reverse order

    }



    // now, set item #123456

    size_t item_index = 123456;

    // TODO check if the index is below the maximum

    size_t chunk_index = item_index / CHUNKSIZE;

    size_t index_into_chunk = item_index % CHUNKSIZE;

    void * item_address = &outer_array[chunk_index][index_into_chunk * ENTRY_SIZE];



    // after having processed one chunk, you can free it:

    free(outer_array[0]);

    outer_array[0] = NULL;

}

There are (roughly) two possibilities how a program can enhance the heap in order to allocate memory:

1. It can obtain a completely new memory block from the OS, indepedent from the "main address space". Then it can use it for allocation and return it to the OS as soon as it is free()d. This happens in some allocators if the allocation size is above a certain threshold.


2. It can enhance the program address space. Then, the new memory is added at the end. After free()ing the last memory block, the program address space can be reduced again. This happens in some allocators if the allocation size is below a certain threshold.

This way, your program's memory footprint decreases over time.