does openmp allocate memory and free all after

c, malloc, memory-leaks, openmp, valgrind

Solution

This highly depends on your compiler and openmp library implementation.

I tried your code with `gcc -fopenmp` version 4.4.6 (GCC) and `libgomp` 1.0.0 and i also get heap blocks which have not been deallocated. As far as I can tell `libgomp` does not kill it's spawned threads at the end of execution and makes the kernel clean up do this.

==85122== HEAP SUMMARY:
==85122==     in use at exit: 2,072 bytes in 4 blocks
==85122==   total heap usage: 203 allocs, 199 frees, 289,816 bytes allocated
==85122== 
==85122== 288 bytes in 1 blocks are possibly lost in loss record 3 of 4
==85122==    at 0x4A05A28: calloc (vg_replace_malloc.c:467)
==85122==    by 0x3793A11792: _dl_allocate_tls (in /lib64/ld-2.12.so)
==85122==    by 0x379460701F: pthread_create@@GLIBC_2.2.5 (in /lib64/libpthread-2.12.so)
==85122==    by 0x4C15509: gomp_team_start (team.c:422)
==85122==    by 0x400BAA: sort2 (in /usr/users/ga002/lamzins/malloc_openmp)
==85122==    by 0x400B28: sort (in /usr/users/ga002/lamzins/malloc_openmp)
==85122==    by 0x400AAA: main (in /usr/users/ga002/lamzins/malloc_openmp)
==85122== 
==85122== LEAK SUMMARY:
==85122==    definitely lost: 0 bytes in 0 blocks
==85122==    indirectly lost: 0 bytes in 0 blocks
==85122==      possibly lost: 288 bytes in 1 blocks
==85122==    still reachable: 1,784 bytes in 3 blocks
==85122==         suppressed: 0 bytes in 0 blocks
==85122== Reachable blocks (those to which a pointer was found) are not shown.
==85122== To see them, rerun with: --leak-check=full --show-reachable=yes
==85122== 
==85122== For counts of detected and suppressed errors, rerun with: -v
==85122== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 6 from 6)

When i compiled your code with `icc -openmp` Version 12.0.2 I got all allocated memory deallocated.

==85218== HEAP SUMMARY:
==85218==     in use at exit: 0 bytes in 0 blocks
==85218==   total heap usage: 841 allocs, 841 frees, 4,364,204 bytes allocated
==85218== 
==85218== All heap blocks were freed -- no leaks are possible

Edit: Also the issue you are describing is known and is not considered a memory leak: http://gcc.1065356.n5.nabble.com/Bug-libgomp-36298-New-gomp-contains-small-memoryleak-td330804.html

Problem

Does openmp allocate memory and free all memory? Because I ran valgrind, and did free all my lists.. Everything that I malloc, did I free. ``` ==11442== HEAP SUMMARY: ==11442== in use at exit: 192 bytes in 1 blocks ==11442== total heap usage: 2,001 allocs, 2,000 frees, 2,917,280 bytes allocated ==11442== ==11442== LEAK SUMMARY: ==11442== definitely lost: 0 bytes in 0 blocks ==11442== indirectly lost: 0 bytes in 0 blocks ==11442== possibly lost: 0 bytes in 0 blocks ==11442== still reachable: 192 bytes in 1 blocks ==11442== suppressed: 0 bytes in 0 blocks ``` If not why can there still be a memory leak in one block? This is my code: ``` #include <stdio.h> #include <stdlib.h> #include <time.h> /*check definition of _OPENMP*/ #ifdef _OPENMP #include <omp.h> #endif #define RMAX 10000000 /*Global variables*/ int arraySizeGlobal; int numberOfthreads; int *aux; /*Functions*/ void sort(int *a); void sort2(int *a, int lo, int hi); void merge(int *a, int lo, int mid, int hi); void Generate_list(int a[], int n); void printlist(int *array); int main(int argc, char* argv[]) { numberOfthreads = strtol(argv[1], NULL, 10); arraySizeGlobal = strtol(argv[2], NULL, 10); //////////////////////////////// int *array; array = malloc(arraySizeGlobal * sizeof(int)); Generate_list(array,arraySizeGlobal); printf("=====================\n"); printf("////Starting list////\n"); printf("=====================\n"); printlist(array); sort(array); printf("=====================\n"); printf("/////Sorted list/////\n"); printf("=====================\n"); printlist(array); free(array); return 0; } void sort(int *a) { aux = malloc(arraySizeGlobal * sizeof(int)); // Allocate space just once. //#pragma omp parallel num_threads(numberOfthreads) //#pragma omp single nowait sort2(a, 0, arraySizeGlobal - 1); free(aux); } void sort2(int *a, int lo, int hi) { // Sort a[lo..hi]. if (hi <= lo) return; int mid = lo + (hi - lo)/2; #pragma omp parallel sections num_threads(numberOfthreads) { #pragma omp section sort2(a, lo, mid); // Sort left half. #pragma omp section sort2(a, mid+1, hi); // Sort right half. } merge(a, lo, mid, hi); // Merge } void merge(int *a, int lo, int mid, int hi) { // Merge a[lo..mid] with a[mid+1..hi]. int i = lo, j = mid+1; int k; #pragma omp parallel for num_threads(numberOfthreads) for (k = lo; k <= hi; k++) // Copy a[lo..hi] to aux[lo..hi]. aux[k] = a[k]; for (k = lo; k <= hi; k++) // Merge back to a[lo..hi]. if (i > mid) a[k] = aux[j++]; else if (j > hi ) a[k] = aux[i++]; else if (aux[j] < aux[i]) a[k] = aux[j++]; else a[k] = aux[i++]; } void printlist(int *array) { int i; for (i = 0; i < arraySizeGlobal; ++i) { printf("%d ", array[i]); } printf("\n"); } void Generate_list(int a[], int n) { int i; srandom(1); for (i = 0; i < n; i++) a[i] = random() % RMAX; } /* Generate_list */ ``` ================================================================================== This code: Came from Algorithms FOURTH EDITION, Robert Sedgewick | Kevin Wayne. It was a java implementation, which I change to a c implementation and paralyzed with openmp ==================================================================================

Original source