1. 12 Aug, 2014 10 commits
  2. 11 Aug, 2014 10 commits
  3. 08 Aug, 2014 13 commits
    • Rob Pike's avatar
      doc/go1.4.txt: go.sys subrepo created · 5a17aaa8
      Rob Pike authored
      CC=golang-codereviews
      https://golang.org/cl/124050043
      5a17aaa8
    • Rob Pike's avatar
      A+C: Joel Stemmer (individual CLA) · f0bfd7b0
      Rob Pike authored
      Generated by a+c.
      
      R=gobot
      CC=golang-codereviews
      https://golang.org/cl/127800043
      f0bfd7b0
    • Joel Stemmer's avatar
      time: Fix missing colon when formatting time zone offsets with seconds · 298c623e
      Joel Stemmer authored
      When formatting time zone offsets with seconds using the stdISO8601Colon
      and stdNumColon layouts, the colon was missing between the hour and minute
      parts.
      
      Fixes #8497.
      
      LGTM=r
      R=golang-codereviews, iant, gobot, r
      CC=golang-codereviews
      https://golang.org/cl/126840043
      298c623e
    • Ian Lance Taylor's avatar
      test: add another test case that gccgo crashed on · f69f45c5
      Ian Lance Taylor authored
      LGTM=bradfitz
      R=golang-codereviews, bradfitz
      CC=golang-codereviews
      https://golang.org/cl/124020044
      f69f45c5
    • Dmitriy Vyukov's avatar
      runtime: bump MaxGcprocs to 32 · 44106a08
      Dmitriy Vyukov authored
      There was a number of improvements related to GC parallelization:
      1. Parallel roots/stacks scanning.
      2. Parallel stack shrinking.
      3. Per-thread workbuf caches.
      4. Workset reduction.
      Currently 32 threads work well.
      go.benchmarks:garbage benchmark on 2 x Intel Xeon E5-2690 (16 HT cores)
      
      1 thread/1 processor:
      time=16405255
      cputime=16386223
      gc-pause-one=546793975
      gc-pause-total=3280763
      
      2 threads/1 processor:
      time=9043497
      cputime=18075822
      gc-pause-one=331116489
      gc-pause-total=2152257
      
      4 threads/1 processor:
      time=4882030
      cputime=19421337
      gc-pause-one=174543105
      gc-pause-total=1134530
      
      8 threads/1 processor:
      time=4134757
      cputime=20097075
      gc-pause-one=158680588
      gc-pause-total=1015555
      
      16 threads/1 processor + HT:
      time=2006706
      cputime=31960509
      gc-pause-one=75425744
      gc-pause-total=460097
      
      16 threads/2 processors:
      time=1513373
      cputime=23805571
      gc-pause-one=56630946
      gc-pause-total=345448
      
      32 threads/2 processors + HT:
      time=1199312
      cputime=37592764
      gc-pause-one=48945064
      gc-pause-total=278986
      
      LGTM=rlh
      R=golang-codereviews, tracey.brendan, rlh
      CC=golang-codereviews, khr, rsc
      https://golang.org/cl/123920043
      44106a08
    • Matthew Dempsky's avatar
      runtime: mark functions as static where possible · 28cf62ed
      Matthew Dempsky authored
      Update #8092
      
      LGTM=dvyukov
      R=golang-codereviews, minux, dvyukov
      CC=golang-codereviews
      https://golang.org/cl/122250043
      28cf62ed
    • Dmitriy Vyukov's avatar
      runtime: fix data race in stackalloc · d6d7170d
      Dmitriy Vyukov authored
      Stack shrinking happens during mark phase,
      and it assumes that it owns stackcache in mcache.
      Stack cache flushing also happens during mark phase,
      and it accesses stackcache's w/o any synchronization.
      This leads to stackcache corruption:
      http://goperfd.appspot.com/log/309af5571dfd7e1817259b9c9cf9bcf9b2c27610
      
      LGTM=khr
      R=khr
      CC=golang-codereviews, rsc
      https://golang.org/cl/126870043
      d6d7170d
    • Russ Cox's avatar
      syscall: ignore EINVAL/ENOENT from readdirent on OS X 10.10 · a83bbc9c
      Russ Cox authored
      On OS X 10.10 Yosemite, if you have a directory that can be returned
      in a single getdirentries64 call (for example, a directory with one file),
      and you read from the directory at EOF twice, you get EOF both times:
              fd = open("dir")
              getdirentries64(fd) returns data
              getdirentries64(fd) returns 0 (EOF)
              getdirentries64(fd) returns 0 (EOF)
      
      But if you remove the file in the middle between the two calls, the
      second call returns an error instead.
              fd = open("dir")
              getdirentries64(fd) returns data
              getdirentries64(fd) returns 0 (EOF)
              remove("dir/file")
              getdirentries64(fd) returns ENOENT/EINVAL
      
      Whether you get ENOENT or EINVAL depends on exactly what was
      in the directory. It is deterministic, just data-dependent.
      
      This only happens in small directories. A directory containing more data
      than fits in a 4k getdirentries64 call will return EOF correctly.
      (It's not clear if the criteria is that the directory be split across multiple
      getdirentries64 calls or that it be split across multiple file system blocks.)
      
      We could change package os to avoid the second read at EOF,
      and maybe we should, but that's a bit involved.
      For now, treat the EINVAL/ENOENT as EOF.
      
      With this CL, all.bash passes on my MacBook Air running
      OS X 10.10 (14A299l) and Xcode 6 beta 5 (6A279r).
      
      I tried filing an issue with Apple using "Feedback Assistant", but it was
      unable to send the report and lost it.
      
      C program reproducing the issue, also at http://swtch.com/~rsc/readdirbug.c:
      
      #include <stdio.h>
      #include <dirent.h>
      #include <unistd.h>
      #include <sys/stat.h>
      #include <stdlib.h>
      #include <fcntl.h>
      #include <errno.h>
      #include <string.h>
      
      static void test(int);
      
      int
      main(void)
      {
              int fd, n;
              DIR *dir;
              struct dirent *dp;
              struct stat st;
              char buf[10000];
              long basep;
              int saw;
      
              if(stat("/tmp/readdirbug", &st) >= 0) {
                      fprintf(stderr, "please rm -r /tmp/readdirbug and run again\n");
                      exit(1);
              }
      
              fprintf(stderr, "mkdir /tmp/readdirbug\n");
              if(mkdir("/tmp/readdirbug", 0777) < 0) {
                      perror("mkdir /tmp/readdirbug");
                      exit(1);
              }
      
              fprintf(stderr, "create /tmp/readdirbug/file1\n");
              if((fd = creat("/tmp/readdirbug/file1", 0666)) < 0) {
                      perror("create /tmp/readdirbug/file1");
                      exit(1);
              }
              close(fd);
      
              test(0);
              test(1);
      
              fprintf(stderr, "ok - everything worked\n");
      }
      
      static void
      test(int doremove)
      {
              DIR *dir;
              struct dirent *dp;
              int numeof;
      
              fprintf(stderr, "\n");
              fprintf(stderr, "opendir /tmp/readdirbug\n");
              dir = opendir("/tmp/readdirbug");
              if(dir == 0) {
                      perror("open /tmp/readdirbug");
                      exit(1);
              }
      
              numeof = 0;
              for(;;) {
                      errno = 0;
                      dp = readdir(dir);
                      if(dp != 0) {
                              fprintf(stderr, "readdir: found %s\n", dp->d_name);
                              continue;
                      }
                      if(errno != 0) {
                              perror("readdir");
                              exit(1);
                      }
                      fprintf(stderr, "readdir: EOF\n");
                      if(++numeof == 3)
                              break;
                      if(doremove) {
                              fprintf(stderr, "rm /tmp/readdirbug/file1\n");
                              if(remove("/tmp/readdirbug/file1") < 0) {
                                      perror("remove");
                                      exit(1);
                              }
                      }
              }
              fprintf(stderr, "closedir\n");
              closedir(dir);
      }
      
      Fixes #8423.
      
      LGTM=bradfitz, r
      R=golang-codereviews, bradfitz, dsymonds, dave, r
      CC=golang-codereviews, iant
      https://golang.org/cl/119530044
      a83bbc9c
    • Dmitriy Vyukov's avatar
      encoding/gob: fix data races in benchmarks · f7832df7
      Dmitriy Vyukov authored
      All goroutines decode into the same value.
      
      LGTM=r
      R=r, abursavich
      CC=golang-codereviews
      https://golang.org/cl/123930043
      f7832df7
    • Mikio Hara's avatar
      cmd/go: fix build in airplane mode · 21f7d83f
      Mikio Hara authored
      LGTM=iant
      R=golang-codereviews, adg, iant
      CC=golang-codereviews
      https://golang.org/cl/122190043
      21f7d83f
    • Alex Brainman's avatar
      debug/pe/testdata: make sure gcc-amd64-mingw-exec has symbols · 40b94405
      Alex Brainman authored
      as per rsc request
      
      LGTM=rsc
      R=rsc
      CC=golang-codereviews
      https://golang.org/cl/123970043
      40b94405
    • Shenghou Ma's avatar
      misc/nacl/testzip.proto: include cmd/internal/* to fix build · be96e52c
      Shenghou Ma authored
      LGTM=adg, dave
      R=golang-codereviews, adg, dave
      CC=golang-codereviews
      https://golang.org/cl/123050043
      be96e52c
    • Alex Brainman's avatar
      os: simplify windows Getwd (fixes build) · 6fb2a05a
      Alex Brainman authored
      Current version of Getwd calls Stat that
      calls Getwd therefore infinite recursion.
      
      LGTM=minux
      R=golang-codereviews, minux
      CC=golang-codereviews
      https://golang.org/cl/119600043
      6fb2a05a
  4. 07 Aug, 2014 7 commits