Created threadsafe MEM_malloc versions in BLI_threads.h, now in use
authorTon Roosendaal <ton@blender.org>
Mon, 30 Jan 2006 11:09:50 +0000 (11:09 +0000)
committerTon Roosendaal <ton@blender.org>
Mon, 30 Jan 2006 11:09:50 +0000 (11:09 +0000)
for compositing code.

Officially malloc/calloc/free is threadsafe, but our secure malloc system
requires all memory blocks to be stored in a single list, so when two
threads write in this list you get conflicts.

source/blender/blenkernel/intern/node_composite.c
source/blender/blenlib/BLI_threads.h
source/blender/blenlib/intern/threads.c
source/blender/render/intern/source/pipeline.c

index 4f246fa984a058bb85e2fc298238a7650f78da5d..e7bfcd722b9763dd84cce58158ed9de506cad5be 100644 (file)
@@ -50,8 +50,8 @@
 
 #include "BLI_arithb.h"
 #include "BLI_blenlib.h"
+#include "BLI_threads.h"
 
-#include "MEM_guardedalloc.h"
 #include "IMB_imbuf.h"
 #include "IMB_imbuf_types.h"
 
@@ -74,16 +74,16 @@ typedef struct CompBuf {
 
 static CompBuf *alloc_compbuf(int sizex, int sizey, int type, int alloc)
 {
-       CompBuf *cbuf= MEM_callocN(sizeof(CompBuf), "compbuf");
+       CompBuf *cbuf= MEM_callocT(sizeof(CompBuf), "compbuf");
        
        cbuf->x= sizex;
        cbuf->y= sizey;
        cbuf->type= type;
        if(alloc) {
                if(cbuf->type==CB_RGBA)
-                       cbuf->rect= MEM_mallocN(4*sizeof(float)*sizex*sizey, "compbuf RGBA rect");
+                       cbuf->rect= MEM_mallocT(4*sizeof(float)*sizex*sizey, "compbuf RGBA rect");
                else
-                       cbuf->rect= MEM_mallocN(sizeof(float)*sizex*sizey, "compbuf Fac rect");
+                       cbuf->rect= MEM_mallocT(sizeof(float)*sizex*sizey, "compbuf Fac rect");
                cbuf->malloc= 1;
        }
        cbuf->disprect.xmin= 0;
@@ -97,8 +97,8 @@ static CompBuf *alloc_compbuf(int sizex, int sizey, int type, int alloc)
 void free_compbuf(CompBuf *cbuf)
 {
        if(cbuf->malloc && cbuf->rect)
-               MEM_freeN(cbuf->rect);
-       MEM_freeN(cbuf);
+               MEM_freeT(cbuf->rect);
+       MEM_freeT(cbuf);
 }
 
 void print_compbuf(char *str, CompBuf *cbuf)
@@ -525,7 +525,7 @@ static void node_composit_exec_composite(void *data, bNode *node, bNodeStack **i
                                CompBuf *outbuf, *zbuf=NULL;
                                
                                if(rr->rectf) 
-                                       MEM_freeN(rr->rectf);
+                                       MEM_freeT(rr->rectf);
                                outbuf= alloc_compbuf(rr->rectx, rr->recty, CB_RGBA, 1);
                                
                                if(in[1]->data==NULL)
@@ -535,7 +535,7 @@ static void node_composit_exec_composite(void *data, bNode *node, bNodeStack **i
                                
                                if(in[2]->data) {
                                        if(rr->rectz) 
-                                               MEM_freeN(rr->rectz);
+                                               MEM_freeT(rr->rectz);
                                        zbuf= alloc_compbuf(rr->rectx, rr->recty, CB_VAL, 1);
                                        composit1_pixel_processor(node, zbuf, in[2]->data, in[2]->vec, do_copy_value);
                                        rr->rectz= zbuf->rect;
@@ -1398,7 +1398,7 @@ static float *make_gausstab(int rad)
        
        n = 2 * rad + 1;
        
-       gausstab = (float *) MEM_mallocN(n * sizeof(float), "gauss");
+       gausstab = (float *) MEM_mallocT(n * sizeof(float), "gauss");
        
        sum = 0.0f;
        for (i = -rad; i <= rad; i++) {
@@ -1421,7 +1421,7 @@ static float *make_bloomtab(int rad)
        
        n = 2 * rad + 1;
        
-       bloomtab = (float *) MEM_mallocN(n * sizeof(float), "bloom");
+       bloomtab = (float *) MEM_mallocT(n * sizeof(float), "bloom");
        
        for (i = -rad; i <= rad; i++) {
                val = pow(1.0 - fabs((float)i)/((float)rad), 4.0);
@@ -1488,7 +1488,7 @@ static void blur_single_image(CompBuf *new, CompBuf *img, float blurx, float blu
        }
        
        /* vertical */
-       MEM_freeN(gausstab);
+       MEM_freeT(gausstab);
        
        rad = ceil(blury);
        if(rad>imgy/2)
@@ -1535,7 +1535,7 @@ static void blur_single_image(CompBuf *new, CompBuf *img, float blurx, float blu
        }
        
        free_compbuf(work);
-       MEM_freeN(gausstab);
+       MEM_freeT(gausstab);
 }
 
 /* reference has to be mapped 0-1, and equal in size */
@@ -1570,7 +1570,7 @@ static void bloom_with_reference(CompBuf *new, CompBuf *img, CompBuf *ref, float
                rady= 1;
        
        x= MAX2(radx, rady);
-       maintabs= MEM_mallocN(x*sizeof(void *), "gauss array");
+       maintabs= MEM_mallocT(x*sizeof(void *), "gauss array");
        for(i= 0; i<x; i++)
                maintabs[i]= make_bloomtab(i+1);
                
@@ -1654,8 +1654,8 @@ static void bloom_with_reference(CompBuf *new, CompBuf *img, CompBuf *ref, float
        
        x= MAX2(radx, rady);
        for(i= 0; i<x; i++)
-               MEM_freeN(maintabs[i]);
-       MEM_freeN(maintabs);
+               MEM_freeT(maintabs[i]);
+       MEM_freeT(maintabs);
        
 }
 
@@ -1700,7 +1700,7 @@ static void blur_with_reference(CompBuf *new, CompBuf *img, CompBuf *ref, float
                rady= 1;
        
        x= MAX2(radx, rady);
-       maintabs= MEM_mallocN(x*sizeof(void *), "gauss array");
+       maintabs= MEM_mallocT(x*sizeof(void *), "gauss array");
        for(i= 0; i<x; i++)
                maintabs[i]= make_gausstab(i+1);
        
@@ -1763,8 +1763,8 @@ static void blur_with_reference(CompBuf *new, CompBuf *img, CompBuf *ref, float
        
        x= MAX2(radx, rady);
        for(i= 0; i<x; i++)
-               MEM_freeN(maintabs[i]);
-       MEM_freeN(maintabs);
+               MEM_freeT(maintabs[i]);
+       MEM_freeT(maintabs);
        
 }
 
index 5ab8c2a0b3fc7a9eeecb2361ccacd2cecee51352..a9927fa08ef811a836255c1aef54e8b9c753f775 100644 (file)
 void   BLI_init_threads        (ListBase *threadbase, int (*do_thread)(void *), int tot);
 int            BLI_available_threads(ListBase *threadbase);
 int            BLI_available_thread_index(ListBase *threadbase);
-void           BLI_insert_thread       (ListBase *threadbase, void *callerdata);
+void   BLI_insert_thread       (ListBase *threadbase, void *callerdata);
 void   BLI_remove_thread       (ListBase *threadbase, void *callerdata);
 void   BLI_end_threads         (ListBase *threadbase);
-
+               
+               /* threadsafe version of MEM_malloc and friends */
+void   *MEM_mallocT(int len, char *name);
+void   *MEM_callocT(int len, char *name);
+void   MEM_freeT(void *poin);
 
 #endif
 
index b404ae5788d94566f982473b7cebf27e7e7c4833..6a306a5c7b199675bbb86570782467981030d205 100644 (file)
@@ -82,6 +82,7 @@ A sample loop can look like this (pseudo c);
        BLI_end_threads(&lb);
 
  ************************************************ */
+static SDL_mutex *_malloc_lock= NULL;
 
 /* just a max for security reasons */
 #define RE_MAX_THREAD  8
@@ -94,8 +95,6 @@ typedef struct ThreadSlot {
        int avail;
 } ThreadSlot;
 
-static ThreadSlot threadslots[RE_MAX_THREAD];
-
 void BLI_init_threads(ListBase *threadbase, int (*do_thread)(void *), int tot)
 {
        int a;
@@ -112,6 +111,8 @@ void BLI_init_threads(ListBase *threadbase, int (*do_thread)(void *), int tot)
                BLI_addtail(threadbase, tslot);
                tslot->do_thread= do_thread;
        }
+       
+       _malloc_lock = SDL_CreateMutex();
 }
 
 /* amount of available threads */
@@ -178,6 +179,35 @@ void BLI_end_threads(ListBase *threadbase)
                }
        }
        BLI_freelistN(threadbase);
+       
+       if(_malloc_lock) SDL_DestroyMutex(_malloc_lock); 
+       _malloc_lock= NULL;
+}
+
+/* ***************** Thread safe MEM_malloc/calloc/free ************************** */
+
+void *MEM_mallocT(int len, char *name)
+{
+       void *mem;
+       if(_malloc_lock) SDL_mutexP(_malloc_lock);
+       mem= MEM_mallocN(len, name);
+       if(_malloc_lock) SDL_mutexV(_malloc_lock);
+       return mem;
+}
+void *MEM_callocT(int len, char *name)
+{
+       void *mem;
+       if(_malloc_lock) SDL_mutexP(_malloc_lock);
+       mem= MEM_callocN(len, name);
+       if(_malloc_lock) SDL_mutexV(_malloc_lock);
+       return mem;
 }
+void MEM_freeT(void *poin)
+{
+       if(_malloc_lock) SDL_mutexP(_malloc_lock);
+       MEM_freeN(poin);
+       if(_malloc_lock) SDL_mutexV(_malloc_lock);
+}
+
 
 /* eof */
index 5780b780b0f0d4b3bb3dfa30b7f99b8db28fbda8..375cb5f3a0c1719e2244d0d3aa75f488403e1960 100644 (file)
@@ -106,7 +106,7 @@ Render R;
 /* ********* alloc and free ******** */
 
 
-SDL_mutex *malloc_lock= NULL;
+static SDL_mutex *malloc_lock= NULL;
 
 void *RE_mallocN(int len, char *name)
 {