[Gc] inline allocation

Peter Wang wangp at students.cs.mu.oz.au
Mon Aug 14 22:52:44 PDT 2006


Hi, the inline allocation code in CVS is slightly broken at the moment.
I have attached an incomplete patch.  However, it still relies on some
symbols defined in private headers, which I understand is not the
intention.  Also, GC_generic_malloc_many() is currently not defined if
thread support is disabled.

Peter
-------------- next part --------------
Index: include/gc_inline.h
===================================================================
RCS file: /cvsroot/bdwgc/bdwgc/include/gc_inline.h,v
retrieving revision 1.2
diff -u -r1.2 gc_inline.h
--- include/gc_inline.h	25 Apr 2006 04:17:59 -0000	1.2
+++ include/gc_inline.h	15 Aug 2006 05:48:46 -0000
@@ -34,9 +34,9 @@
 #endif /* __GNUC__ */
 
 /* The ultimately general inline allocation macro.  Allocate an object	*/
-/* of size bytes, putting the resulting pointer in result.  Tiny_fl is	*/
+/* of size granules, putting the resulting pointer in result.  Tiny_fl is */
 /* a "tiny" free list array, which will be used first, if the size	*/
-/* is appropriate.  If bytes is too large, we allocate with 		*/
+/* is appropriate.  If granules is too large, we allocate with 		*/
 /* default_expr instead.  If we need to refill the free list, we use	*/
 /* GC_generic_malloc_many with the indicated kind.			*/
 /* Tiny_fl should be an array of GC_TINY_FREELISTS void * pointers.	*/
@@ -47,7 +47,7 @@
 /* be initialized to (void *)0.						*/
 /* We rely on much of this hopefully getting optimized away in the	*/
 /* num_direct = 0 case.							*/
-/* Particularly if bytes is constant, this should generate a small	*/
+/* Particularly if granules is constant, this should generate a small	*/
 /* amount of code.							*/
 # define GC_FAST_MALLOC_GRANS(result,granules,tiny_fl,num_direct,\
 			      kind,default_expr,init) \
@@ -59,12 +59,12 @@
         void *my_entry=*my_fl; \
 	void *next; \
  \
-	while (GC_EXPECT((word)my_entry \
+	while (GC_EXPECT((GC_word)my_entry \
 				<= num_direct + GC_TINY_FREELISTS + 1, 0)) { \
 	    /* Entry contains counter or NULL */ \
-	    if ((word)my_entry - 1 < num_direct) { \
+	    if ((GC_word)my_entry - 1 < num_direct) { \
 		/* Small counter value, not NULL */ \
-                *my_fl = (ptr_t)my_entry + granules + 1; \
+                *my_fl = (void *)my_entry + granules + 1; \
                 result = default_expr; \
 		goto out; \
             } else { \
@@ -74,7 +74,7 @@
 				       kind, my_fl); \
 		my_entry = *my_fl; \
                 if (my_entry == 0) { \
-		    result = GC_oom_fn(bytes); \
+		    result = GC_oom_fn(granules*GC_GRANULE_BYTES); \
 		    goto out; \
 		} \
 	    } \
@@ -84,7 +84,7 @@
         *my_fl = next; \
 	init; \
         PREFETCH_FOR_WRITE(next); \
-        GC_ASSERT(GC_size(result) >= bytes + EXTRA_BYTES); \
+        GC_ASSERT(GC_size(result) >= granules*GC_GRANULE_BYTES + EXTRA_BYTES); \
         GC_ASSERT((kind) == PTRFREE || ((word *)result)[1] == 0); \
       out: ; \
    } \
@@ -102,17 +102,17 @@
 /* a global array.							*/
 # define GC_MALLOC_WORDS(result,n,tiny_fl) \
 {	\
-    size_t grans = WORDS_TO_WHOLE_GRANULES(n); \
+    size_t grans = GC_WORDS_TO_WHOLE_GRANULES(n); \
     GC_FAST_MALLOC_GRANS(result, grans, tiny_fl, 0, \
-			 NORMAL, GC_malloc(grans*GRANULE_BYTES), \
+			 NORMAL, GC_malloc(grans*GC_GRANULE_BYTES), \
 			 *(void **)result = 0); \
 }
 
 # define GC_MALLOC_ATOMIC_WORDS(result,n,tiny_fl) \
 {	\
-    size_t grans = WORDS_TO_WHOLE_GRANULES(n); \
+    size_t grans = GC_WORDS_TO_WHOLE_GRANULES(n); \
     GC_FAST_MALLOC_GRANS(result, grans, tiny_fl, 0, \
-			 PTRFREE, GC_malloc_atomic(grans*GRANULE_BYTES), \
+			 PTRFREE, GC_malloc_atomic(grans*GC_GRANULE_BYTES), \
 			 /* no initialization */); \
 }
 
@@ -120,9 +120,9 @@
 /* And once more for two word initialized objects: */
 # define GC_CONS(result, first, second, tiny_fl) \
 {	\
-    size_t grans = WORDS_TO_WHOLE_GRANULES(2); \
+    size_t grans = GC_WORDS_TO_WHOLE_GRANULES(2); \
     GC_FAST_MALLOC_GRANS(result, grans, tiny_fl, 0, \
-			 NORMAL, GC_malloc(grans*GRANULE_BYTES), \
+			 NORMAL, GC_malloc(grans*GC_GRANULE_BYTES), \
 			 *(void **)result = (void *)(first)); \
     ((void **)(result))[1] = (void *)(second);	\
 }
Index: include/gc_tiny_fl.h
===================================================================
RCS file: /cvsroot/bdwgc/bdwgc/include/gc_tiny_fl.h,v
retrieving revision 1.2
diff -u -r1.2 gc_tiny_fl.h
--- include/gc_tiny_fl.h	6 May 2006 00:22:41 -0000	1.2
+++ include/gc_tiny_fl.h	15 Aug 2006 05:48:46 -0000
@@ -27,7 +27,7 @@
  */
 
 /*
- * We always set GRANULE_BYTES to twice the length of a pointer.
+ * We always set GC_GRANULE_BYTES to twice the length of a pointer.
  * This means that all allocation requests are rounded up to the next
  * multiple of 16 on 64-bit architectures or 8 on 32-bit architectures.
  * This appears to be a reasonable compromise between fragmentation overhead
@@ -61,7 +61,7 @@
 #if GC_GRANULE_WORDS == 2
 #  define GC_WORDS_TO_GRANULES(n) ((n)>>1)
 #else
-#  define GC_WORDS_TO_GRANULES(n) ((n)*sizeof(void *)/GRANULE_BYTES)
+#  define GC_WORDS_TO_GRANULES(n) ((n)*sizeof(void *)/GC_GRANULE_BYTES)
 #endif
 
 /* A "tiny" free list header contains TINY_FREELISTS pointers to 	*/
@@ -76,7 +76,7 @@
 # endif
 #endif /* !GC_TINY_FREELISTS */
 
-/* The ith free list corresponds to size i*GRANULE_BYTES	*/
+/* The ith free list corresponds to size i*GC_GRANULE_BYTES	*/
 /* Internally to the collector, the index can be computed with	*/
 /* ROUNDED_UP_GRANULES.  Externally, we don't know whether	*/
 /* DONT_ADD_BYTE_AT_END is set, but the client should know.	*/


More information about the Gc mailing list