code review 9199044: runtime: inline size to class conversion in malloc()

runtime: inline size to class conversion in malloc()
Also change table type from int32[] to int8[] to save space in L1$.

benchmark          old ns/op    new ns/op    delta
BenchmarkMalloc           42           40   -4.68%

[dvyukov, 2013-05-13 08:43:00]

Hello golang-dev@googlegroups.com,

I'd like you to review this change to
https://dvyukov%40google.com@code.google.com/p/go/

[bradfitz, 2013-05-13 15:51:49]

LGTM

But I'd add a comment in malloc.goc saying that it's the inlined version of
SizeToClass.



On Mon, May 13, 2013 at 1:43 AM, <dvyukov@google.com> wrote:

> Reviewers: golang-dev1,
>
> Message:
> Hello golang-dev@googlegroups.com,
>
> I'd like you to review this change to
>
https://dvyukov%40google.com@**code.google.com/p/go/<http://40google.com@code...
>
>
> Description:
> runtime: inline size to class conversion in malloc()
> Also change table type from int32[] to int8[] to save space in L1$.
>
> benchmark          old ns/op    new ns/op    delta
> BenchmarkMalloc           42           40   -4.68%
>
> Please review this at
https://codereview.appspot.**com/9199044/<https://codereview.appspot.com/9199...
>
> Affected files:
>   M src/pkg/runtime/malloc.goc
>   M src/pkg/runtime/malloc.h
>   M src/pkg/runtime/msize.c
>
>
> Index: src/pkg/runtime/malloc.goc
> ==============================**==============================**=======
> --- a/src/pkg/runtime/malloc.goc
> +++ b/src/pkg/runtime/malloc.goc
> @@ -50,7 +50,10 @@
>         c->local_nmalloc++;
>         if(size <= MaxSmallSize) {
>                 // Allocate from mcache free lists.
> -               sizeclass = runtime·SizeToClass(size);
> +               if(size <= 1024-8)
> +                       sizeclass = runtime·size_to_class8[(size+**7)>>3];
> +               else
> +                       sizeclass =
runtime·size_to_class128[(**size-1024+127)
> >> 7];
>                 size = runtime·class_to_size[**sizeclass];
>                 v = runtime·MCache_Alloc(c, sizeclass, size, zeroed);
>                 if(v == nil)
> Index: src/pkg/runtime/malloc.h
> ==============================**==============================**=======
> --- a/src/pkg/runtime/malloc.h
> +++ b/src/pkg/runtime/malloc.h
> @@ -275,6 +275,8 @@
>  extern int32   runtime·class_to_size[**NumSizeClasses];
>  extern int32   runtime·class_to_allocnpages[**NumSizeClasses];
>  extern int32   runtime·class_to_**transfercount[NumSizeClasses];
> +extern int8    runtime·size_to_class8[1024/8 + 1];
> +extern int8    runtime·size_to_class128[(**MaxSmallSize-1024)/128 + 1];
>  extern void    runtime·InitSizes(void);
>
>
> Index: src/pkg/runtime/msize.c
> ==============================**==============================**=======
> --- a/src/pkg/runtime/msize.c
> +++ b/src/pkg/runtime/msize.c
> @@ -42,17 +42,17 @@
>  // size divided by 128 (rounded up).  The arrays are filled in
>  // by InitSizes.
>
> -static int32 size_to_class8[1024/8 + 1];
> -static int32 size_to_class128[(**MaxSmallSize-1024)/128 + 1];
> +int8 runtime·size_to_class8[1024/8 + 1];
> +int8 runtime·size_to_class128[(**MaxSmallSize-1024)/128 + 1];
>
> -int32
> -runtime·SizeToClass(int32 size)
> +static int32
> +SizeToClass(int32 size)
>  {
>         if(size > MaxSmallSize)
>                 runtime·throw("SizeToClass - invalid size");
>         if(size > 1024-8)
> -               return size_to_class128[(size-1024+**127) >> 7];
> -       return size_to_class8[(size+7)>>3];
> +               return runtime·size_to_class128[(**size-1024+127) >> 7];
> +       return runtime·size_to_class8[(size+**7)>>3];
>  }
>
>  void
> @@ -111,16 +111,16 @@
>         nextsize = 0;
>         for (sizeclass = 1; sizeclass < NumSizeClasses; sizeclass++) {
>                 for(; nextsize < 1024 && nextsize <= runtime·class_to_size[
> **sizeclass]; nextsize+=8)
> -                       size_to_class8[nextsize/8] = sizeclass;
> +                       runtime·size_to_class8[**nextsize/8] = sizeclass;
>                 if(nextsize >= 1024)
>                         for(; nextsize <= runtime·class_to_size[**sizeclass];
> nextsize += 128)
> -                               size_to_class128[(nextsize-**1024)/128] =
> sizeclass;
> +                              
runtime·size_to_class128[(**nextsize-1024)/128]
> = sizeclass;
>         }
>
>         // Double-check SizeToClass.
>         if(0) {
>                 for(n=0; n < MaxSmallSize; n++) {
> -                       sizeclass = runtime·SizeToClass(n);
> +                       sizeclass = 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");
> @@ -157,12 +157,14 @@
>                         runtime·printf(" %d", runtime·class_to_size[**
> sizeclass]);
>                 runtime·printf("\n\n");
>                 runtime·printf("size_to_**class8:");
> -               for(i=0; i<nelem(size_to_class8); i++)
> -                       runtime·printf(" %d=>%d(%d)\n", i*8,
> size_to_class8[i], runtime·class_to_size[size_to_**class8[i]]);
> +               for(i=0; i<nelem(runtime·size_to_**class8); i++)
> +                       runtime·printf(" %d=>%d(%d)\n", i*8,
> runtime·size_to_class8[i],
> +                               runtime·class_to_size[runtime·**
> size_to_class8[i]]);
>                 runtime·printf("\n");
>                 runtime·printf("size_to_**class128:");
> -               for(i=0; i<nelem(size_to_class128); i++)
> -                       runtime·printf(" %d=>%d(%d)\n", i*128,
> size_to_class128[i], runtime·class_to_size[size_to_**class128[i]]);
> +               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");
>
>
> --
>
> ---You received this message because you are subscribed to the Google
> Groups "golang-dev" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to
golang-dev+unsubscribe@**googlegroups.com<golang-dev%2Bunsubscribe@googlegrou...
> .
> For more options, visit
https://groups.google.com/**groups/opt_out<https://groups.google.com/groups/o...
> .
>
>
>

[dvyukov, 2013-05-13 15:59:54]

On 2013/05/13 15:51:49, bradfitz wrote:
> LGTM
> 
> But I'd add a comment in malloc.goc saying that it's the inlined version of
> SizeToClass.


Done.

[r, 2013-05-14 22:47:34]

LGTM

[dvyukov, 2013-05-15 07:03:00]

*** Submitted as https://code.google.com/p/go/source/detail?r=0fe374e88745 ***

runtime: inline size to class conversion in malloc()
Also change table type from int32[] to int8[] to save space in L1$.

benchmark          old ns/op    new ns/op    delta
BenchmarkMalloc           42           40   -4.68%

R=golang-dev, bradfitz, r
CC=golang-dev
https://codereview.appspot.com/9199044