free

I am trying to allocate device memory, copy to it, perform the calculations on the GPU, copy the results back and then free up the device memory I allocated. I wanted to make sure that I wasn't going over the limit and I wanted to see if I would have enough memory in the shared memory space to dump a few arrays. When I allocate device memory, there are no errors being returned. When I use cudaMemGetInfo to check the amount of memory allocated, it looks like one cudaMalloc hasn't allocated any memory. Also when I try to free the memory, it looks like only one pointer is freed. I am using the

Where can I find the code for malloc my gcc compiler is using at the moment? I actually want to write my own malloc function which will be a little different from the original one. I know I can use hooks et all, but I want to see the real code. The POSIX interface of malloc is defined here . If you want to find out how the C library in GNU/Linux (glibc) implements malloc , go and get the source code from http://ftp.gnu.org/gnu/glibc/ and look at the malloc/malloc.c file. There is also the base documentation of the Memory Allocator by Doug Lea that describes the theory of a m (emory) alloc

i'm doing some tests allocating and deallocating memory. This is the code i'm using: #include <stdlib.h> #include <stdio.h> #define WAVE_SIZE 100000000 int main(int argc,char* argv[]){ int i; int **p; printf("%d allocs...\n",WAVE_SIZE); // Malloc printf("Allocating memory...\n"); p = (int**)malloc(WAVE_SIZE*sizeof(int*)); for(i = 0;i < WAVE_SIZE;i++) p[i] = (int*)malloc(sizeof(int)); // Break printf("Press a key to continue...\n"); scanf("%*s"); // Dealloc printf("Deallocating memory...\n"); for(i = 0;i < WAVE_SIZE;i++) free(p[i]); free(p); // Break printf("Press a key to continue...\n");

Possible Duplicate: ( POD )freeing memory : is delete[] equal to delete ? Does delete deallocate the elements beyond the first in an array? char *s = new char[n]; delete s; Does it matter in the above case seeing as all the elements of s are allocated contiguously, and it shouldn't be possible to delete only a portion of the array? For more complex types, would delete call the destructor of objects beyond the first one? Object *p = new Object[n]; delete p; How can delete[] deduce the number of Object s beyond the first, wouldn't this mean it must know the size of the allocated memory region?

Suppose I write my code very defensively and always check the return types from all the functions that I call. So I go like: char* function() { char* mem = get_memory(100); // first allocation if (!mem) return NULL; struct binder* b = get_binder('regular binder'); // second allocation if (!b) { free(mem); return NULL; } struct file* f = mk_file(); // third allocation if (!f) { free(mem); free_binder(b); return NULL; } // ... } Notice how quickly free() things get out of control. If some of the function fails, I have to free every single allocation before. The code quickly becomes ugly and all

Until today I lived in belief that calling free() on memory space releases it for further allocation without any other modifications. Especially, considering this SO question that clearly states that free() DOESN'T zero out memory. Yet, let's consider this piece of code (test.c): #include<stdlib.h> #include<stdio.h> int main() { int* pointer; if (NULL == (pointer = malloc(sizeof(*pointer)))) return EXIT_FAILURE; *pointer = 1337; printf("Before free(): %p, %d\n", pointer, *pointer); free(pointer); printf("After free(): %p, %d\n", pointer, *pointer); return EXIT_SUCCESS; } Compiling (both GCC