runtime: contiguous stacks

src/pkg/runtime/msize.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Malloc small size classes.
 //
 // See malloc.h for overview.
 //
 // The size classes are chosen so that rounding an allocation
 // request up to the next size class wastes at most 12.5% (1.125x).
@@ skipping 26 matching lines @@
 // sizes >= 1024 and <= MaxSmallSize to their class.
 // All objects are 8-aligned, so the first array is indexed by
 // the size divided by 8 (rounded up).  Objects >= 1024 bytes
 // are 128-aligned, so the second array is indexed by the
 // size divided by 128 (rounded up).  The arrays are filled in
 // by InitSizes.
 
 int8 runtime·size_to_class8[1024/8 + 1];
 int8 runtime·size_to_class128[(MaxSmallSize-1024)/128 + 1];
 
-static int32
-SizeToClass(int32 size)
+int32
+runtime·SizeToClass(int32 size)
 {
         if(size > MaxSmallSize)
                 runtime·throw("SizeToClass - invalid size");
         if(size > 1024-8)
                 return runtime·size_to_class128[(size-1024+127) >> 7];
         return runtime·size_to_class8[(size+7)>>3];
 }
 
 void
 runtime·InitSizes(void)
@@ skipping 53 matching lines @@
                 for(; nextsize < 1024 && nextsize <= runtime·class_to_size[sizeclass]; nextsize+=8)
                         runtime·size_to_class8[nextsize/8] = sizeclass;
                 if(nextsize >= 1024)
                         for(; nextsize <= runtime·class_to_size[sizeclass]; nextsize += 128)
                                 runtime·size_to_class128[(nextsize-1024)/128] = sizeclass;
         }
 
         // Double-check SizeToClass.
         if(0) {
                 for(n=0; n < MaxSmallSize; n++) {
-                        sizeclass = SizeToClass(n);
+                        sizeclass = runtime·SizeToClass(n);
                         if(sizeclass < 1 || sizeclass >= NumSizeClasses || runtime·class_to_size[sizeclass] < n) {
                                 runtime·printf("size=%d sizeclass=%d runtime·class_to_size=%d\n", n, sizeclass, runtime·class_to_size[sizeclass]);
                                 runtime·printf("incorrect SizeToClass");
                                 goto dump;
                         }
                         if(sizeclass > 1 && runtime·class_to_size[sizeclass-1] >= n) {
                                 runtime·printf("size=%d sizeclass=%d runtime·class_to_size=%d\n", n, sizeclass, runtime·class_to_size[sizeclass]);
                                 runtime·printf("SizeToClass too big");
                                 goto dump;
                         }
@@ skipping 18 matching lines @@
                                 runtime·class_to_size[runtime·size_to_class8[i]]);
                 runtime·printf("\n");
                 runtime·printf("size_to_class128:");
                 for(i=0; i<nelem(runtime·size_to_class128); i++)
                         runtime·printf(" %d=>%d(%d)\n", i*128, runtime·size_to_class128[i],
                                 runtime·class_to_size[runtime·size_to_class128[i]]);
                 runtime·printf("\n");
         }
         runtime·throw("InitSizes failed");
 }