recvg := sg.g
if sg.elem != nil {
- // This is the only place in the entire runtime where one goroutine
- // writes to the stack of another goroutine. The GC assumes that
- // stack writes only happen when the goroutine is running and are
- // only done by that goroutine. Using a write barrier is sufficient to
- // make up for violating that assumption, but the write barrier has to work.
- // typedmemmove will call heapBitsBulkBarrier, but the target bytes
- // are not in the heap, so that will not help. We arrange to call
- // memmove and typeBitsBulkBarrier instead.
- memmove(sg.elem, ep, c.elemtype.size)
- typeBitsBulkBarrier(c.elemtype, uintptr(sg.elem), c.elemtype.size)
- sg.elem = nil
+ syncsend(c, sg, ep)
}
recvg.param = unsafe.Pointer(sg)
if sg.releasetime != 0 {
return true
}
+func syncsend(c *hchan, sg *sudog, elem unsafe.Pointer) {
+ // Send on unbuffered channel is the only operation
+ // in the entire runtime where one goroutine
+ // writes to the stack of another goroutine. The GC assumes that
+ // stack writes only happen when the goroutine is running and are
+ // only done by that goroutine. Using a write barrier is sufficient to
+ // make up for violating that assumption, but the write barrier has to work.
+ // typedmemmove will call heapBitsBulkBarrier, but the target bytes
+ // are not in the heap, so that will not help. We arrange to call
+ // memmove and typeBitsBulkBarrier instead.
+ memmove(sg.elem, elem, c.elemtype.size)
+ typeBitsBulkBarrier(c.elemtype, uintptr(sg.elem), c.elemtype.size)
+ sg.elem = nil
+}
+
func closechan(c *hchan) {
if c == nil {
panic("close of nil channel")
--- /dev/null
+// Copyright 2015 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.
+
+package runtime_test
+
+import (
+ "runtime"
+ "sync"
+ "testing"
+)
+
+type response struct {
+}
+
+type myError struct {
+}
+
+func (myError) Error() string { return "" }
+
+func doRequest(useSelect bool) (*response, error) {
+ type async struct {
+ resp *response
+ err error
+ }
+ ch := make(chan *async, 0)
+ done := make(chan struct{}, 0)
+
+ if useSelect {
+ go func() {
+ select {
+ case ch <- &async{resp: nil, err: myError{}}:
+ case <-done:
+ }
+ }()
+ } else {
+ go func() {
+ ch <- &async{resp: nil, err: myError{}}
+ }()
+ }
+
+ r := <-ch
+ runtime.Gosched()
+ return r.resp, r.err
+}
+
+func TestChanSendSelectBarrier(t *testing.T) {
+ testChanSendBarrier(true)
+}
+
+func TestChanSendBarrier(t *testing.T) {
+ testChanSendBarrier(false)
+}
+
+func testChanSendBarrier(useSelect bool) {
+ var wg sync.WaitGroup
+ outer := 100
+ inner := 100000
+ if testing.Short() {
+ outer = 10
+ inner = 1000
+ }
+ for i := 0; i < outer; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ var garbage []byte
+ for j := 0; j < inner; j++ {
+ _, err := doRequest(useSelect)
+ _, ok := err.(myError)
+ if !ok {
+ panic(1)
+ }
+ garbage = make([]byte, 1<<10)
+ }
+ global = garbage
+ }()
+ }
+ wg.Wait()
+}