Efficiently appending a large array with zeros?

Question

I have an array named A that contains random floats, with its size anywhere in the range from [10000, 1000000]. This array is a randomly generated argument to my function, and in order to operate on it I am trying to preemptively append/pad it with 10000 zeros in an efficient manner. I am worried that appending A's allocated memory will corrupt the heap, so instead I allocate new memory, memcopy A, and memset 10000 trailing floats in the new Array to 0.0.

void *ArrayPadder(float *A){
    int pad = 10000;
    float *Apadded = (float*)malloc((sizeof(A)+pad)*sizeof(float));
    memcpy(Apadded, A, sizeof(A));
    memset(Apadded+sizeof(A), 0.0, pad);
    return Apadded;
}

Can anyone suggest a more efficient way of accomplishing this?

EDIT: Apologies for the delay but I added some clarification. The reason I can't just pre-allocate the correct memory space (510000 floats) is because the array is actually of random size, containing random floats. I chose 500000 in an attempt to simplify the question, which is now fixed.

Answer 1

Not really a more efficient way, but a more accurate way:

memset(Apadded+sizeof(A), 0, pad * sizeof(float));

as if the size of float is 4, your code only initializes the first pad / sizeof(float) = 10000 / 4 = 2500 elements

Note that I used 0 and not 0.0 as the second parameter, as memset takes an int and sets its (low byte) value to all of the bytes.

Answer 2

I am trying to efficiently append/pad it with 10000 zeros

Appending and padding are not necessarily the same thing. I assume you want to grow an existing chunk of memory by 10,000 elements.

Why don't you just allocate the correct size up front and be done with it?

#define BASE_SIZE 500000
#define PAD_SIZE  10000

/* ... */

float *data = malloc((BASE_SIZE + PAD_SIZE) * sizeof(float));
if(!data) {
    /* do something */
}

memset(data + BASE_SIZE, 0, PAD_SIZE * sizeof(float));
/* last PAD_SIZE elements are now 0 */

---

Also note that memset takes the number of bytes to set, not elements, so this:

memset(Apadded+sizeof(A), 0.0, pad);

Is wrong. Should be pad * sizeof(float). pad is the number of elements, sizeof(float) gives the number of bytes per element.

Answer 3

This depends how A is defined. If it's allocated on the heap, just use realloc():

Apadded = realloc(A, new_size);

Answer 4

Jordan, there are a few issues with your code. You don't show how A is defined but your use of sizeof(A) in the malloc call must be wrong. To allocate the expanded memory, you need either malloc, calloc or realloc. realloc can only be used if A is pointer to memory area that was allocated (eg by malloc) on the heap.

float *Apadded = realloc(A, (number_of_entries_in_A + pad) * sizeof(float));

realloc will copy the contents of A to Apadded but will leave the padding area uninitialised. Note that realloc can fail, in which case A still exists and must later be freed.

If A was statically allocated, then you need malloc or calloc. calloc will initialise the memory to zero for you but since you are going to copy A to Apapped, it is wasteful. So malloc would be best.

float *Apadded = malloc((number_of_entries_in_A + pad) * sizeof(float));

Note that number_of_entries_in_A is not the same as sizeof(A). Note also, no cast in C.

To initialise the padding area, you can use memset with sizeof(A). But note that if A is a pointer this will fail as sizeof(A) will be just the size of the pointer, not the array.

memcpy(Apadded, A, sizeof(A));
memset(Apadded+sizeof(A), 0, pad);

Note also that, although it is probably so, there may be no guarantee that floating point 0.0 is represented by all zeros.