code review 12440044: runtime: tune append crossover on amd64 and 386

src/pkg/runtime/slice.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.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "type.h"
 #include "typekind.h"
 #include "malloc.h"
 #include "race.h"
@@ skipping 77 matching lines @@
                 // write x[len(x):len(x)+len(y)]
                 if(m <= x.cap)
                         runtime·racewriterangepc(ret.array+ret.len*w, y.len*w, pc, runtime·appendslice);
         }
 
         // A very common case is appending bytes. Small appends can avoid the overhead of memmove.
         // We can generalize a bit here, and just pick small-sized appends.
         p = ret.array+ret.len*w;
         q = y.array;
         w *= y.len;
-        if(appendCrossover && w <= appendCrossover) {

[r, 2013/08/05 10:34:19]

appendCrossover is not a boolean.

+        if(appendCrossover > 0 && w <= appendCrossover) {
                 if(p <= q || w <= p-q) // No overlap.
                         while(w-- > 0)
                                 *p++ = *q++;
                 else {
                         p += w;
                         q += w;
                         while(w-- > 0)
                                 *--p = *--q;
                 }
         } else {
@@ skipping 32 matching lines @@
                         runtime·racereadrangepc(x.array, x.len, pc, runtime·appendstr);
                 // write x[len(x):len(x)+len(y)]
                 if(m <= x.cap)
                         runtime·racewriterangepc(ret.array+ret.len, y.len, pc, runtime·appendstr);
         }
 
         // Small appends can avoid the overhead of memmove.
         w = y.len;
         p = ret.array+ret.len;
         q = y.str;
-        if(appendCrossover && w <= appendCrossover) {
+        if(appendCrossover > 0 && w <= appendCrossover) {
                 while(w-- > 0)
                         *p++ = *q++;
         } else {
                 runtime·memmove(p, q, w);
         }
         ret.len += y.len;
         FLUSH(&ret);
 }
 
 
@@ skipping 127 matching lines @@
 void
 runtime·printslice(Slice a)
 {
         runtime·prints("[");
         runtime·printint(a.len);
         runtime·prints("/");
         runtime·printint(a.cap);
         runtime·prints("]");
         runtime·printpointer(a.array);
 }