src/mm/boehm-gc/thread_local_alloc.c

   1 /*
   2  * Copyright (c) 2000-2005 by Hewlett-Packard Company.  All rights reserved.
   3  *
   4  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   5  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   6  *
   7  * Permission is hereby granted to use or copy this program
   8  * for any purpose,  provided the above notices are retained on all copies.
   9  * Permission to modify the code and to distribute modified code is granted,
  10  * provided the above notices are retained, and a notice that the code was
  11  * modified is included with the above copyright notice.
  12  */
  13
  14 #include "config.h"
  15
  16 #include "private/gc_priv.h"
  17
  18 # if defined(THREAD_LOCAL_ALLOC)
  19
  20 #include "private/thread_local_alloc.h"
  21 #include "gc_inline.h"
  22
  23 # include <stdlib.h>
  24
  25 #if defined(USE_COMPILER_TLS)
  26   __thread
  27 #elif defined(USE_WIN32_COMPILER_TLS)
  28   __declspec(thread)
  29 #endif
  30 GC_key_t GC_thread_key;
  31
  32 static GC_bool keys_initialized;
  33
  34 /* Return a single nonempty freelist fl to the global one pointed to    */
  35 /* by gfl.      */
  36
  37 static void return_single_freelist(void *fl, void **gfl)
  38 {
  39     void *q, **qptr;
  40
  41     if (*gfl == 0) {
  42       *gfl = fl;
  43     } else {
  44       GC_ASSERT(GC_size(fl) == GC_size(*gfl));
  45       /* Concatenate: */
  46         for (qptr = &(obj_link(fl)), q = *qptr;
  47              (word)q >= HBLKSIZE; qptr = &(obj_link(q)), q = *qptr);
  48         GC_ASSERT(0 == q);
  49         *qptr = *gfl;
  50         *gfl = fl;
  51     }
  52 }
  53
  54 /* Recover the contents of the freelist array fl into the global one gfl.*/
  55 /* We hold the allocator lock.                                          */
  56 static void return_freelists(void **fl, void **gfl)
  57 {
  58     int i;
  59
  60     for (i = 1; i < TINY_FREELISTS; ++i) {
  61         if ((word)(fl[i]) >= HBLKSIZE) {
  62           return_single_freelist(fl[i], gfl+i);
  63         }
  64         /* Clear fl[i], since the thread structure may hang around.     */
  65         /* Do it in a way that is likely to trap if we access it.       */
  66         fl[i] = (ptr_t)HBLKSIZE;
  67     }
  68     /* The 0 granule freelist really contains 1 granule objects.        */
  69 #   ifdef GC_GCJ_SUPPORT
  70       if (fl[0] == ERROR_FL) return;
  71 #   endif
  72     if ((word)(fl[0]) >= HBLKSIZE) {
  73         return_single_freelist(fl[0], gfl+1);
  74     }
  75 }
  76
  77 /* Each thread structure must be initialized.   */
  78 /* This call must be made from the new thread.  */
  79 /* Caller holds allocation lock.                */
  80 void GC_init_thread_local(GC_tlfs p)
  81 {
  82     int i;
  83
  84     if (!keys_initialized) {
  85         if (0 != GC_key_create(&GC_thread_key, 0)) {
  86             ABORT("Failed to create key for local allocator");
  87         }
  88         keys_initialized = TRUE;
  89     }
  90     if (0 != GC_setspecific(GC_thread_key, p)) {
  91         ABORT("Failed to set thread specific allocation pointers");
  92     }
  93     for (i = 1; i < TINY_FREELISTS; ++i) {
  94         p -> ptrfree_freelists[i] = (void *)1;
  95         p -> normal_freelists[i] = (void *)1;
  96 #       ifdef GC_GCJ_SUPPORT
  97           p -> gcj_freelists[i] = (void *)1;
  98 #       endif
  99     }
 100     /* Set up the size 0 free lists.    */
 101     /* We now handle most of them like regular free lists, to ensure    */
 102     /* That explicit deallocation works.  However, allocation of a      */
 103     /* size 0 "gcj" object is always an error.                          */
 104     p -> ptrfree_freelists[0] = (void *)1;
 105     p -> normal_freelists[0] = (void *)1;
 106 #   ifdef GC_GCJ_SUPPORT
 107         p -> gcj_freelists[0] = ERROR_FL;
 108 #   endif
 109 }
 110
 111 #ifdef GC_GCJ_SUPPORT
 112   extern void ** GC_gcjobjfreelist;
 113 #endif
 114
 115 /* We hold the allocator lock.  */
 116 void GC_destroy_thread_local(GC_tlfs p)
 117 {
 118     /* We currently only do this from the thread itself or from */
 119     /* the fork handler for a child process.                    */
 120 #   ifndef HANDLE_FORK
 121       GC_ASSERT(GC_getspecific(GC_thread_key) == (void *)p);
 122 #   endif
 123     return_freelists(p -> ptrfree_freelists, GC_aobjfreelist);
 124     return_freelists(p -> normal_freelists, GC_objfreelist);
 125 #   ifdef GC_GCJ_SUPPORT
 126         return_freelists(p -> gcj_freelists, GC_gcjobjfreelist);
 127 #   endif
 128 }
 129
 130 #if defined(GC_ASSERTIONS) && defined(GC_PTHREADS) && !defined(CYGWIN32) \
 131     && !defined(GC_WIN32_PTHREADS)
 132 # include <pthread.h>
 133   extern char * GC_lookup_thread(pthread_t id);
 134 #endif
 135
 136 #if defined(GC_ASSERTIONS) && defined(GC_WIN32_THREADS)
 137   extern char * GC_lookup_thread(int id);
 138 #endif
 139
 140 void * GC_malloc(size_t bytes)
 141 {
 142     size_t granules = ROUNDED_UP_GRANULES(bytes);
 143     void *tsd;
 144     void *result;
 145     void **tiny_fl;
 146
 147 #   if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC)
 148       GC_key_t k = GC_thread_key;
 149       if (EXPECT(0 == k, 0)) {
 150         /* We haven't yet run GC_init_parallel.  That means     */
 151         /* we also aren't locking, so this is fairly cheap.     */
 152         return GC_core_malloc(bytes);
 153       }
 154       tsd = GC_getspecific(k);
 155 #   else
 156       GC_ASSERT(GC_is_initialized);
 157       tsd = GC_getspecific(GC_thread_key);
 158 #   endif
 159 #   if defined(REDIRECT_MALLOC) && defined(USE_PTHREAD_SPECIFIC)
 160       if (EXPECT(NULL == tsd, 0)) {
 161         return GC_core_malloc(bytes);
 162       }
 163 #   endif
 164 #   ifdef GC_ASSERTIONS
 165       /* We can't check tsd correctly, since we don't have access to    */
 166       /* the right declarations.  But we can check that it's close.     */
 167       LOCK();
 168       {
 169 #       if defined(GC_WIN32_THREADS)
 170           char * me = (char *)GC_lookup_thread_inner(GetCurrentThreadId());
 171 #       else
 172           char * me = GC_lookup_thread(pthread_self());
 173 #       endif
 174         GC_ASSERT((char *)tsd > me && (char *)tsd < me + 1000);
 175       }
 176       UNLOCK();
 177 #   endif
 178     tiny_fl = ((GC_tlfs)tsd) -> normal_freelists;
 179     GC_FAST_MALLOC_GRANS(result, granules, tiny_fl, DIRECT_GRANULES,
 180                          NORMAL, GC_core_malloc(bytes), obj_link(result)=0);
 181     return result;
 182 }
 183
 184 void * GC_malloc_atomic(size_t bytes)
 185 {
 186     size_t granules = ROUNDED_UP_GRANULES(bytes);
 187     void *result;
 188     void **tiny_fl;
 189
 190     GC_ASSERT(GC_is_initialized);
 191     tiny_fl = ((GC_tlfs)GC_getspecific(GC_thread_key))
 192                                         -> ptrfree_freelists;
 193     GC_FAST_MALLOC_GRANS(result, bytes, tiny_fl, DIRECT_GRANULES,
 194                          PTRFREE, GC_core_malloc_atomic(bytes), 0/* no init */);
 195     return result;
 196 }
 197
 198 #ifdef GC_GCJ_SUPPORT
 199
 200 #include "include/gc_gcj.h"
 201
 202 #ifdef GC_ASSERTIONS
 203   extern GC_bool GC_gcj_malloc_initialized;
 204 #endif
 205
 206 extern int GC_gcj_kind;
 207
 208 /* Gcj-style allocation without locks is extremely tricky.  The         */
 209 /* fundamental issue is that we may end up marking a free list, which   */
 210 /* has freelist links instead of "vtable" pointers.  That is usually    */
 211 /* OK, since the next object on the free list will be cleared, and      */
 212 /* will thus be interpreted as containg a zero descriptor.  That's fine */
 213 /* if the object has not yet been initialized.  But there are           */
 214 /* interesting potential races.                                         */
 215 /* In the case of incremental collection, this seems hopeless, since    */
 216 /* the marker may run asynchronously, and may pick up the pointer to    */
 217 /* the next freelist entry (which it thinks is a vtable pointer), get   */
 218 /* suspended for a while, and then see an allocated object instead      */
 219 /* of the vtable.  This made be avoidable with either a handshake with  */
 220 /* the collector or, probably more easily, by moving the free list      */
 221 /* links to the second word of each object.  The latter isn't a         */
 222 /* universal win, since on architecture like Itanium, nonzero offsets   */
 223 /* are not necessarily free.  And there may be cache fill order issues. */
 224 /* For now, we punt with incremental GC.  This probably means that      */
 225 /* incremental GC should be enabled before we fork a second thread.     */
 226 void * GC_gcj_malloc(size_t bytes,
 227                      void * ptr_to_struct_containing_descr)
 228 {
 229   if (GC_EXPECT(GC_incremental, 0)) {
 230     return GC_core_gcj_malloc(bytes, ptr_to_struct_containing_descr);
 231   } else {
 232     size_t granules = ROUNDED_UP_GRANULES(bytes);
 233     void *result;
 234     void **tiny_fl = ((GC_tlfs)GC_getspecific(GC_thread_key))
 235                                         -> gcj_freelists;
 236     GC_ASSERT(GC_gcj_malloc_initialized);
 237     GC_FAST_MALLOC_GRANS(result, bytes, tiny_fl, DIRECT_GRANULES,
 238                          GC_gcj_kind,
 239                          GC_core_gcj_malloc(bytes,
 240                                             ptr_to_struct_containing_descr),
 241                          {AO_compiler_barrier();
 242                           *(void **)result = ptr_to_struct_containing_descr;});
 243         /* This forces the initialization of the "method ptr".          */
 244         /* This is necessary to ensure some very subtle properties      */
 245         /* required if a GC is run in the middle of such an allocation. */
 246         /* Here we implicitly also assume atomicity for the free list.  */
 247         /* and method pointer assignments.                              */
 248         /* We must update the freelist before we store the pointer.     */
 249         /* Otherwise a GC at this point would see a corrupted           */
 250         /* free list.                                                   */
 251         /* A real memory barrier is not needed, since the               */
 252         /* action of stopping this thread will cause prior writes       */
 253         /* to complete.                                                 */
 254         /* We assert that any concurrent marker will stop us.           */
 255         /* Thus it is impossible for a mark procedure to see the        */
 256         /* allocation of the next object, but to see this object        */
 257         /* still containing a free list pointer.  Otherwise the         */
 258         /* marker, by misinterpreting the freelist link as a vtable     */
 259         /* pointer, might find a random "mark descriptor" in the next   */
 260         /* object.                                                      */
 261     return result;
 262   }
 263 }
 264
 265 #endif /* GC_GCJ_SUPPORT */
 266
 267 /* The thread support layer must arrange to mark thread-local   */
 268 /* free lists explicitly, since the link field is often         */
 269 /* invisible to the marker.  It knows hoe to find all threads;  */
 270 /* we take care of an individual thread freelist structure.     */
 271 void GC_mark_thread_local_fls_for(GC_tlfs p)
 272 {
 273     ptr_t q;
 274     int j;
 275
 276     for (j = 1; j < TINY_FREELISTS; ++j) {
 277       q = p -> ptrfree_freelists[j];
 278       if ((word)q > HBLKSIZE) GC_set_fl_marks(q);
 279       q = p -> normal_freelists[j];
 280       if ((word)q > HBLKSIZE) GC_set_fl_marks(q);
 281 #     ifdef GC_GCJ_SUPPORT
 282         q = p -> gcj_freelists[j];
 283         if ((word)q > HBLKSIZE) GC_set_fl_marks(q);
 284 #     endif /* GC_GCJ_SUPPORT */
 285     }
 286 }
 287
 288 #if defined(GC_ASSERTIONS)
 289     /* Check that all thread-local free-lists in p are completely marked.       */
 290     void GC_check_tls_for(GC_tlfs p)
 291     {
 292         ptr_t q;
 293         int j;
 294
 295         for (j = 1; j < TINY_FREELISTS; ++j) {
 296           q = p -> ptrfree_freelists[j];
 297           if ((word)q > HBLKSIZE) GC_check_fl_marks(q);
 298           q = p -> normal_freelists[j];
 299           if ((word)q > HBLKSIZE) GC_check_fl_marks(q);
 300 #         ifdef GC_GCJ_SUPPORT
 301             q = p -> gcj_freelists[j];
 302             if ((word)q > HBLKSIZE) GC_check_fl_marks(q);
 303 #         endif /* GC_GCJ_SUPPORT */
 304         }
 305     }
 306 #endif /* GC_ASSERTIONS */
 307
 308 # else  /* !THREAD_LOCAL_ALLOC  */
 309
 310 #   define GC_destroy_thread_local(t)
 311
 312 # endif /* !THREAD_LOCAL_ALLOC */
 313