[SOLVED] Is there anything analog to what would recalloc be?

ejspeiro · 09-20-2012, 09:02 PM

Hi there guys,

I was writing some code for my research work, and I noticed that every time I reallocate my memory, i.e. every time I invoke remalloc, it actually does it work, but the reallocated array is not initialized.

I goggled for something as recalloc, but I do not see it out there.

Would it make sense for me to try to create it? Is there anything like it already out there?

Thanks in advanced!

\m/

tronayne · 09-21-2012, 08:53 AM

From the manual page for malloc():

Quote:

The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not initialized.

The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be unchanged in the range from the start of the region up to the minimum of the old and new sizes.

If you want to clear the memory, use the memset() function:

Code:

(void) memset ((void *) ptr, '\0', sizeof (ptr));

Where ptr is the pointer to allocated memory and '\0' (null) is set in every position (you can set whatever you'd like).

See the manual page for malloc and for memset.

Hope this helps some.

ejspeiro · 09-21-2012, 10:23 AM

tronayne: Thanks for your reply, which makes sense.

Nonetheless, my original concerns stands: If you had already filled your array with say, 16 elements, and you are interested in reallocating it with extra 16 elements... would it make sense to use realloc and then memset? I do NOT think so, because memset would initialize the previously assigned values, wouldn't it? Unless, memset is somehow instructed to initialize only the "new" space.

Is there a way of doing that, considering the arguments memset takes?

Thanks.

sundialsvcs · 09-21-2012, 10:41 AM

The stated purpose of realloc() would be defeated by setting the reallocated area to binary zeros.

There is a very-efficient library subroutine which will set an arbitrarily-large block of memory to known-zero. (This is actually how "calloc()" does it.) It may actually use a system call which invalidates the page-table entries for the specified area so that they become flagged as zero-pages without paging them in as a "memset()" type of call might do. Paged-out pages remain paged-out, but when and if demand-paged back in, they will be all-zeros.

tronayne · 09-21-2012, 10:43 AM

Quote:

Originally Posted by ejspeiro

Is there a way of doing that, considering the arguments memset takes?

Sure. memset() takes a pointer to where you want to start, an initialize character (like '\0', NULL) and a length. You can do a little quick arithmetic, even fancy-schmancy arithmetic that's dynamic to figure out where to point and how far to go.

So, if you've got an area of memory that's 16 bytes long, and you know the beginning address, and you realloc() to add 16 bytes... eh?

Hope this helps some.

ntubski · 09-21-2012, 10:44 AM

Quote:

Originally Posted by tronayne

If you want to clear the memory, use the memset() function:

Code:

(void) memset ((void *) ptr, '\0', sizeof (ptr));

You probably don't want to use sizeof(ptr) there.

Quote:

Originally Posted by ejspeiro

If you had already filled your array with say, 16 elements, and you are interested in reallocating it with extra 16 elements... would it make sense to use realloc and then memset? I do NOT think so, because memset would initialize the previously assigned values, wouldn't it? Unless, memset is somehow instructed to initialize only the "new" space.

Is there a way of doing that, considering the arguments memset takes?

Code:

memset(ptr + old_len, 0, sizeof(*ptr) * (new_len - old_len));

ejspeiro · 09-21-2012, 10:45 AM

sundialsvcs:

Quote:

The stated purpose of realloc() would be defeated by setting the reallocated area to binary zeroes.

Why?

tronayne: Wow! Cool! Yes... I suddenly thought on doing that... I does help a lot; thanks!

\m/

\m/

NevemTeve · 09-21-2012, 10:48 AM

Code:

size_t requested;
size_t allocated;
char *ptr;

ptr= realloc (ptr, requested);
if (allocated<requested) memset (ptr+allocated, 0, requested-allocated);
allocated= requested;

tronayne · 09-21-2012, 11:02 AM

Quote:

Originally Posted by ntubski

You probably don't want to use sizeof(ptr) there.

Oops (or, duh!); ought to be sizeof(*ptr).

Fumble finger.

ejspeiro · 09-21-2012, 08:33 PM

Hi guys... well this is the implementation that I have tried:

Code:

double *array;
int amount_of_elements;
int max_amount_of_elements;
int requested_memory;
int allocated_memory;
int ii;

array = NULL;
amount_of_elements = 4;
max_amount_of_elements = 16;
allocated_memory = 0;

while (amount_of_elements < max_amount_of_elements) {

  requested_memory = amount_of_elements*sizeof(double);

  // Reallocate the array AND initialize the new attained memory if the allocation is successful:
  array = (double*) realloc(array, requested_memory);
  if ((array != NULL) && (requested_memory > allocated_memory)) {
    memset(array + allocated_memory, 0, requested_memory - allocated_memory);
  } else {
    printf("Error.\n");
  }

  // If the reallocation worked, then update the amount of allocated memory:
  allocated_memory = requested_memory;

  // Print the array to make sure that the new memory interval has been indeed initialized:
  for (ii = 0; ii < amount_of_elements; ii++) {
    printf("%.3g ", array[ii]);
  }
  putchar('\n');

  // Fill the array to make sure that the new memory interval can be used:
  for (ii = 0; ii < amount_of_elements; ii++) {
    array[ii] = ii;
  }

  // Print the fill the array to make sure that the new memory interval can be used:
  for (ii = 0; ii < amount_of_elements; ii++) {
    printf("%.3g ", array[ii]);
  }
  putchar('\n');

  // Try with more elements:
  amount_of_elements = amount_of_elements + amount_of_elements;
}

free(array);

What am I doing wrong in terms of resetting? Because, this is the output that I get:

Code:

0 0 0 0 
0 1 2 3 
0 1 2 3 nan 2.37e-320 1.09e-312 1.09e-312 
0 1 2 3 4 5 6 7

As you can see... the first time, I realloc and successfully initialize, but for the second time... I have problem with the initialization to 0s, as it can be noticed by the presence of 'nan' and weird non-zero numbers as 2.37e-320.

Any hints?

I tried to use the bzero function, but since it is kind of an analog to memset, in the sense that you still have to specify the correct limits, I have the same issue.

Thanks!

firstfire · 09-21-2012, 09:59 PM

Hi.

Quote:

Any hints?

Yes. Read carefully the description of memset() and realloc() functions in man pages:

Quote:

void *memset(void *s, int c, size_t n);
The memset() function fills the first n bytes of the memory area pointed to by s with the constant byte c.

Quote:

void *realloc(void *ptr, size_t size);
The realloc() function changes the size of the memory block pointed to by ptr to size bytes.

You see what I mean? Sizes are in bytes. Only char variable occupies 1 byte of memory. Each double variable occupies few bytes. So, when you need a place in memory for, say N doubles, you should specify N*sizeof(double) (bytes).

ejspeiro · 09-21-2012, 10:32 PM

Hi firstfire,

thanks for your reply. But I really believe that the size of a double, i.e., 8 B, is already being considered, given the definition of requested_memory:

Code:

requested_memory = amount_of_elements*sizeof(double);
// Reallocate the array AND initialize the new attained memory if the allocation is successful:
array = (double*) realloc(array, requested_memory);

Furthermore, when I state the amount of data in memset... am I failing on doing it? Because, and please correct me if I am wrong, both values should have the info on the size of the data type within their definitions:

Code:

requested_memory - allocated_memory = amount_of_elements_iteration_ii*sizeof(double) - amount_of_elements_iteration_(ii-1)*sizeof(double) = [amount_of_elements_iteration_ii - amount_of_elements_iteration_(ii-1)]*sizeof(double)

Is this making nay sense?

Thanks!

firstfire · 09-21-2012, 11:49 PM

Hi.

The problem is here

Code:

memset(array + allocated_memory, 0, requested_memory - allocated_memory);

When you write array+allocated_memory, because array is (double*), that is equivalent to &array[allocated_memory], which is definitely not what you wanted (so, array is too smart, it knows, that it consists of doubles). To overcome this difficulty you may write

Code:

memset((void*)array + allocated_memory, 0, (requested_memory - allocated_memory));

ejspeiro · 09-24-2012, 01:36 PM

firstfire: Thanks! That completely solved the problem... and it makes perfect sense... I guess I don't quite understand (void*) well enough!

I am calling this one solved... here is the complete code that works:

Code:

      double *array;
      int amount_of_elements;
      int max_amount_of_elements;
      int requested_memory;
      int allocated_memory;
      int ii;

      array = NULL;
      amount_of_elements = 4;
      max_amount_of_elements = 16;
      allocated_memory = 0;
      while (amount_of_elements < max_amount_of_elements) {
        requested_memory = amount_of_elements*sizeof(double);
        array = (double*) realloc(array, requested_memory);
        if ((array != NULL) && (requested_memory > allocated_memory)) {
          memset( (void *)array + allocated_memory, 0, requested_memory - allocated_memory);
        } else {
          printf("Error.\n");
        }
        allocated_memory = requested_memory;
        for (ii = 0; ii < amount_of_elements; ii++) {
          printf("%.3g ", array[ii]);
        }
        putchar('\n');
        for (ii = 0; ii < amount_of_elements; ii++) {
          array[ii] = ii;
        }
        for (ii = 0; ii < amount_of_elements; ii++) {
          printf("%.3g ", array[ii]);
        }
        putchar('\n');
        amount_of_elements = amount_of_elements + amount_of_elements;
      }
      free(array);

Yielding the following output:

Code:

0 0 0 0 
0 1 2 3 
0 1 2 3 0 0 0 0 
0 1 2 3 4 5 6 7

From here, one could wrap the whole thing up to a recalloc function

Thanks everybody.