1. 18 Nov, 2015 20 commits
  2. 17 Nov, 2015 17 commits
  3. 16 Nov, 2015 3 commits
    • Robert Griesemer's avatar
      test: fix test case · fbe855ba
      Robert Griesemer authored
      Issue introduced by https://go-review.googlesource.com/#/c/16920/ .
      
      TBR=rsc
      
      Change-Id: I2a0e0c81f641f869568230837c566913f6538f37
      Reviewed-on: https://go-review.googlesource.com/16990
      Run-TryBot: Robert Griesemer <gri@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRobert Griesemer <gri@golang.org>
      fbe855ba
    • Austin Clements's avatar
      runtime: make mcache.tiny a uintptr · 4d39bb6a
      Austin Clements authored
      mcache.tiny is in non-GC'd memory, but points to heap memory. As a
      result, there may or may not be write barriers when writing to
      mcache.tiny. Make it clearer that funny things are going on by making
      mcache.tiny a uintptr instead of an unsafe.Pointer.
      
      Change-Id: I732a5b7ea17162f196a9155154bbaff8d4d00eac
      Reviewed-on: https://go-review.googlesource.com/16963
      Run-TryBot: Austin Clements <austin@google.com>
      Reviewed-by: default avatarRuss Cox <rsc@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      4d39bb6a
    • Austin Clements's avatar
      runtime: clear tiny alloc cache in mark term, not sweep term · 835c83b4
      Austin Clements authored
      The tiny alloc cache is maintained in a pointer from non-GC'd memory
      (mcache) to heap memory and hence must be handled carefully.
      
      Currently we clear the tiny alloc cache during sweep termination and,
      if it is assigned to a non-nil value during concurrent marking, we
      depend on a write barrier to keep the new value alive. However, while
      the compiler currently always generates this write barrier, we're
      treading on thin ice because write barriers may not happen for writes
      to non-heap memory (e.g., typedmemmove). Without this lucky write
      barrier, the GC may free a current tiny block while it's still
      reachable by the tiny allocator, leading to later memory corruption.
      
      Change this code so that, rather than depending on the write barrier,
      we simply clear the tiny cache during mark termination when we're
      clearing all of the other mcaches. If the current tiny block is
      reachable from regular pointers, it will be retained; if it isn't
      reachable from regular pointers, it may be freed, but that's okay
      because there won't be any pointers in non-GC'd memory to it.
      
      Change-Id: I8230980d8612c35c2997b9705641a1f9f865f879
      Reviewed-on: https://go-review.googlesource.com/16962
      Run-TryBot: Austin Clements <austin@google.com>
      Reviewed-by: default avatarRuss Cox <rsc@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      835c83b4