runtime: faster strings

Use FlagNoPointers and do not zeroize memory when allocate strings.
test/garbage/parser.out        old         new
run #1                     32.923s     32.065s
run #2                     33.047s     31.931s
run #3                     32.702s     31.841s
run #4                     32.718s     31.838s
run #5                     32.702s     31.868s

R=golang-dev, rsc
CC=golang-dev
https://golang.org/cl/5259041

diff --git a/src/cmd/prof/gopprof b/src/cmd/prof/gopprof
index 83438b7cd6e6f10dfb2580deb9f684ed2a0f09b4..49052ac064c1d467671f25d7da1044e8c3a6595f 100755 (executable)
--- a/src/cmd/prof/gopprof
+++ b/src/cmd/prof/gopprof
@@ -2615,7 +2615,6 @@ sub RemoveUninterestingFrames {
                       'mal',
                       'runtime.new',
                       'makeslice1',
-                      'runtime.gostringsize',
                       'runtime.malloc',
                       'unsafe.New',
                       'runtime.mallocgc',

diff --git a/src/pkg/runtime/string.goc b/src/pkg/runtime/string.goc
index 8c59bdd337d434613a84227f8c6baae26eb29d3b..53cd84c6e62822c28eac459abad7a5c7b94d6f17 100644 (file)
--- a/src/pkg/runtime/string.goc
+++ b/src/pkg/runtime/string.goc
@@ -35,16 +35,18 @@ runtime·findnullw(uint16 *s)
 
 uint32 runtime·maxstring = 256;
 
-String
-runtime·gostringsize(int32 l)
+static String
+gostringsize(int32 l)
 {
        String s;
        uint32 ms;
 
        if(l == 0)
                return runtime·emptystring;
-       s.str = runtime·mal(l+1);      // leave room for NUL for C runtime (e.g., callers of getenv)
+       // leave room for NUL for C runtime (e.g., callers of getenv)
+       s.str = runtime·mallocgc(l+1, FlagNoPointers, 1, 0);
        s.len = l;
+       s.str[l] = 0;
        for(;;) {
                ms = runtime·maxstring;
                if((uint32)l <= ms || runtime·cas(&runtime·maxstring, ms, (uint32)l))
@@ -60,7 +62,7 @@ runtime·gostring(byte *str)
        String s;
 
        l = runtime·findnull(str);
-       s = runtime·gostringsize(l);
+       s = gostringsize(l);
        runtime·memmove(s.str, str, l);
        return s;
 }
@@ -70,7 +72,7 @@ runtime·gostringn(byte *str, int32 l)
 {
        String s;
 
-       s = runtime·gostringsize(l);
+       s = gostringsize(l);
        runtime·memmove(s.str, str, l);
        return s;
 }
@@ -100,18 +102,23 @@ runtime·gostringnocopy(byte *str)
 String
 runtime·gostringw(uint16 *str)
 {
-       int32 n, i;
+       int32 n1, n2, i;
        byte buf[8];
        String s;
 
-       n = 0;
-       for(i=0; str[i]; i++)
-               n += runtime·runetochar(buf, str[i]);
-       s = runtime·gostringsize(n+4);
-       n = 0;
+       n1 = 0;
        for(i=0; str[i]; i++)
-               n += runtime·runetochar(s.str+n, str[i]);
-       s.len = n;
+               n1 += runtime·runetochar(buf, str[i]);
+       s = gostringsize(n1+4);
+       n2 = 0;
+       for(i=0; str[i]; i++) {
+               // check for race
+               if(n2 >= n1)
+                       break;
+               n2 += runtime·runetochar(s.str+n2, str[i]);
+       }
+       s.len = n2;
+       s.str[s.len] = 0;
        return s;
 }
 
@@ -125,7 +132,7 @@ runtime·catstring(String s1, String s2)
        if(s2.len == 0)
                return s1;
 
-       s3 = runtime·gostringsize(s1.len + s2.len);
+       s3 = gostringsize(s1.len + s2.len);
        runtime·memmove(s3.str, s1.str, s1.len);
        runtime·memmove(s3.str+s1.len, s2.str, s2.len);
        return s3;
@@ -144,7 +151,7 @@ concatstring(int32 n, String *s)
                l += s[i].len;
        }
        
-       out = runtime·gostringsize(l);
+       out = gostringsize(l);
        l = 0;
        for(i=0; i<n; i++) {
                runtime·memmove(out.str+l, s[i].str, s[i].len);
@@ -254,17 +261,18 @@ func slicestring1(si String, lindex int32) (so String) {
 }
 
 func intstring(v int64) (s String) {
-       s = runtime·gostringsize(8);
+       s = gostringsize(8);
        s.len = runtime·runetochar(s.str, v);
+       s.str[s.len] = 0;
 }
 
 func slicebytetostring(b Slice) (s String) {
-       s = runtime·gostringsize(b.len);
+       s = gostringsize(b.len);
        runtime·memmove(s.str, b.array, s.len);
 }
 
 func stringtoslicebyte(s String) (b Slice) {
-       b.array = runtime·mallocgc(s.len, FlagNoPointers, 1, 1);
+       b.array = runtime·mallocgc(s.len, FlagNoPointers, 1, 0);
        b.len = s.len;
        b.cap = s.len;
        runtime·memmove(b.array, s.str, s.len);
@@ -281,7 +289,7 @@ func sliceinttostring(b Slice) (s String) {
                siz1 += runtime·runetochar(dum, a[i]);
        }
 
-       s = runtime·gostringsize(siz1+4);
+       s = gostringsize(siz1+4);
        siz2 = 0;
        for(i=0; i<b.len; i++) {
                // check for race
@@ -290,6 +298,7 @@ func sliceinttostring(b Slice) (s String) {
                siz2 += runtime·runetochar(s.str+siz2, a[i]);
        }
        s.len = siz2;
+       s.str[s.len] = 0;
 }
 
 func stringtosliceint(s String) (b Slice) {
@@ -307,7 +316,7 @@ func stringtosliceint(s String) (b Slice) {
                n++;
        }
 
-       b.array = runtime·mallocgc(n*sizeof(r[0]), FlagNoPointers, 1, 1);
+       b.array = runtime·mallocgc(n*sizeof(r[0]), FlagNoPointers, 1, 0);
        b.len = n;
        b.cap = n;
        p = s.str;