code review 54220043: runtime/race: race instrument reads/writes in select cases

src/pkg/runtime/chan.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 "race.h"
 #include "malloc.h"
 #include "../../cmd/ld/textflag.h"
@@ skipping 23 matching lines @@
 
 // The garbage collector is assuming that Hchan can only contain pointers into the stack
 // and cannot contain pointers into the heap.
 struct  Hchan
 {
         uintgo  qcount;                 // total data in the q
         uintgo  dataqsiz;               // size of the circular q
         uint16  elemsize;
         uint16  pad;                    // ensures proper alignment of the buffer that follows Hchan in memory
         bool    closed;
-        Alg*    elemalg;                // interface for element type
+        Type*   elemtype;               // element type
         uintgo  sendx;                  // send index
         uintgo  recvx;                  // receive index
         WaitQ   recvq;                  // list of recv waiters
         WaitQ   sendq;                  // list of send waiters
         Lock;
 };
 
 uint32 runtime·Hchansize = sizeof(Hchan);
 
 // Buffer follows Hchan immediately in memory.
@@ skipping 48 matching lines @@
                 runtime·throw("makechan: invalid channel element type");
         if((sizeof(*c)%MAXALIGN) != 0 || elem->align > MAXALIGN)
                 runtime·throw("makechan: bad alignment");
 
         if(hint < 0 || (intgo)hint != hint || (elem->size > 0 && hint > MaxMem / elem->size))
                 runtime·panicstring("makechan: size out of range");
 
         // allocate memory in one call
         c = (Hchan*)runtime·mallocgc(sizeof(*c) + hint*elem->size, (uintptr)t | TypeInfo_Chan, 0);
         c->elemsize = elem->size;
-        c->elemalg = elem->alg;
+        c->elemtype = elem;
         c->dataqsiz = hint;
 
         if(debug)
                 runtime·printf("makechan: chan=%p; elemsize=%D; elemalg=%p; dataqsiz=%D\n",
                         c, (int64)elem->size, elem->alg, (int64)c->dataqsiz);
 
         return c;
 }
 
 // For reflect
@@ skipping 43 matching lines @@
                 if(pres != nil) {
                         *pres = false;
                         return;
                 }
                 runtime·park(nil, nil, "chan send (nil chan)");
                 return;  // not reached
         }
 
         if(debug) {
                 runtime·printf("chansend: chan=%p; elem=", c);
-                c->elemalg->print(c->elemsize, ep);
+                c->elemtype->alg->print(c->elemsize, ep);
                 runtime·prints("\n");
         }
 
         t0 = 0;
         mysg.releasetime = 0;
         if(runtime·blockprofilerate > 0) {
                 t0 = runtime·cputicks();
                 mysg.releasetime = -1;
         }
 
         runtime·lock(c);
         if(raceenabled)
                 runtime·racereadpc(c, pc, runtime·chansend);
         if(c->closed)
                 goto closed;
 
         if(c->dataqsiz > 0)
                 goto asynch;
 
         sg = dequeue(&c->recvq);
         if(sg != nil) {
                 if(raceenabled)
                         racesync(c, sg);
                 runtime·unlock(c);
 
                 gp = sg->g;
                 gp->param = sg;
                 if(sg->elem != nil)
-                        c->elemalg->copy(c->elemsize, sg->elem, ep);
+                        c->elemtype->alg->copy(c->elemsize, sg->elem, ep);
                 if(sg->releasetime)
                         sg->releasetime = runtime·cputicks();
                 runtime·ready(gp);
 
                 if(pres != nil)
                         *pres = true;
                 return;
         }
 
         if(pres != nil) {
@@ skipping 37 matching lines @@
                 enqueue(&c->sendq, &mysg);
                 runtime·park(runtime·unlock, c, "chan send");
 
                 runtime·lock(c);
                 goto asynch;
         }
 
         if(raceenabled)
                 runtime·racerelease(chanbuf(c, c->sendx));
 
-        c->elemalg->copy(c->elemsize, chanbuf(c, c->sendx), ep);
+        c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->sendx), ep);
         if(++c->sendx == c->dataqsiz)
                 c->sendx = 0;
         c->qcount++;
 
         sg = dequeue(&c->recvq);
         if(sg != nil) {
                 gp = sg->g;
                 runtime·unlock(c);
                 if(sg->releasetime)
                         sg->releasetime = runtime·cputicks();
@@ skipping 49 matching lines @@
         if(c->closed)
                 goto closed;
 
         sg = dequeue(&c->sendq);
         if(sg != nil) {
                 if(raceenabled)
                         racesync(c, sg);
                 runtime·unlock(c);
 
                 if(ep != nil)
-                        c->elemalg->copy(c->elemsize, ep, sg->elem);
+                        c->elemtype->alg->copy(c->elemsize, ep, sg->elem);
                 gp = sg->g;
                 gp->param = sg;
                 if(sg->releasetime)
                         sg->releasetime = runtime·cputicks();
                 runtime·ready(gp);
 
                 if(selected != nil)
                         *selected = true;
                 if(received != nil)
                         *received = true;
@@ skipping 45 matching lines @@
                 runtime·park(runtime·unlock, c, "chan receive");
 
                 runtime·lock(c);
                 goto asynch;
         }
 
         if(raceenabled)
                 runtime·raceacquire(chanbuf(c, c->recvx));
 
         if(ep != nil)
-                c->elemalg->copy(c->elemsize, ep, chanbuf(c, c->recvx));
-        c->elemalg->copy(c->elemsize, chanbuf(c, c->recvx), nil);
+                c->elemtype->alg->copy(c->elemsize, ep, chanbuf(c, c->recvx));
+        c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->recvx), nil);
         if(++c->recvx == c->dataqsiz)
                 c->recvx = 0;
         c->qcount--;
 
         sg = dequeue(&c->sendq);
         if(sg != nil) {
                 gp = sg->g;
                 runtime·unlock(c);
                 if(sg->releasetime)
                         sg->releasetime = runtime·cputicks();
                 runtime·ready(gp);
         } else
                 runtime·unlock(c);
 
         if(selected != nil)
                 *selected = true;
         if(received != nil)
                 *received = true;
         if(mysg.releasetime > 0)
                 runtime·blockevent(mysg.releasetime - t0, 2);
         return;
 
 closed:
         if(ep != nil)
-                c->elemalg->copy(c->elemsize, ep, nil);
+                c->elemtype->alg->copy(c->elemsize, ep, nil);
         if(selected != nil)
                 *selected = true;
         if(received != nil)
                 *received = false;
         if(raceenabled)
                 runtime·raceacquire(c);
         runtime·unlock(c);
         if(mysg.releasetime > 0)
                 runtime·blockevent(mysg.releasetime - t0, 2);
 }
@@ skipping 563 matching lines @@
 
         if(debug)
                 runtime·printf("wait-return: sel=%p c=%p cas=%p kind=%d\n",
                         sel, c, cas, cas->kind);
 
         if(cas->kind == CaseRecv) {
                 if(cas->receivedp != nil)
                         *cas->receivedp = true;
         }
 
+        if(raceenabled) {
+                if(cas->kind == CaseRecv && cas->sg.elem != nil)
+                        runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, runtime·chanrecv);
+                else if(cas->kind == CaseSend)
+                        runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, runtime·chansend);
+        }
+
         selunlock(sel);
         goto retc;
 
 asyncrecv:
         // can receive from buffer
-        if(raceenabled)
+        if(raceenabled) {
+                if(cas->sg.elem != nil)
+                        runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, runtime·chanrecv);
                 runtime·raceacquire(chanbuf(c, c->recvx));
+        }
         if(cas->receivedp != nil)
                 *cas->receivedp = true;
         if(cas->sg.elem != nil)
-                c->elemalg->copy(c->elemsize, cas->sg.elem, chanbuf(c, c->recvx));
-        c->elemalg->copy(c->elemsize, chanbuf(c, c->recvx), nil);
+                c->elemtype->alg->copy(c->elemsize, cas->sg.elem, chanbuf(c, c->recvx));
+        c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->recvx), nil);
         if(++c->recvx == c->dataqsiz)
                 c->recvx = 0;
         c->qcount--;
         sg = dequeue(&c->sendq);
         if(sg != nil) {
                 gp = sg->g;
                 selunlock(sel);
                 if(sg->releasetime)
                         sg->releasetime = runtime·cputicks();
                 runtime·ready(gp);
         } else {
                 selunlock(sel);
         }
         goto retc;
 
 asyncsend:
         // can send to buffer
-        if(raceenabled)
+        if(raceenabled) {
                 runtime·racerelease(chanbuf(c, c->sendx));
-        c->elemalg->copy(c->elemsize, chanbuf(c, c->sendx), cas->sg.elem);
+                runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, runtime·chansend);
+        }
+        c->elemtype->alg->copy(c->elemsize, chanbuf(c, c->sendx), cas->sg.elem);
         if(++c->sendx == c->dataqsiz)
                 c->sendx = 0;
         c->qcount++;
         sg = dequeue(&c->recvq);
         if(sg != nil) {
                 gp = sg->g;
                 selunlock(sel);
                 if(sg->releasetime)
                         sg->releasetime = runtime·cputicks();
                 runtime·ready(gp);
         } else {
                 selunlock(sel);
         }
         goto retc;
 
 syncrecv:
         // can receive from sleeping sender (sg)
-        if(raceenabled)
+        if(raceenabled) {
+                if(cas->sg.elem != nil)
+                        runtime·racewriteobjectpc(cas->sg.elem, c->elemtype, cas->pc, runtime·chanrecv);
                 racesync(c, sg);
+        }
         selunlock(sel);
         if(debug)
                 runtime·printf("syncrecv: sel=%p c=%p o=%d\n", sel, c, o);
         if(cas->receivedp != nil)
                 *cas->receivedp = true;
         if(cas->sg.elem != nil)
-                c->elemalg->copy(c->elemsize, cas->sg.elem, sg->elem);
+                c->elemtype->alg->copy(c->elemsize, cas->sg.elem, sg->elem);
         gp = sg->g;
         gp->param = sg;
         if(sg->releasetime)
                 sg->releasetime = runtime·cputicks();
         runtime·ready(gp);
         goto retc;
 
 rclose:
         // read at end of closed channel
         selunlock(sel);
         if(cas->receivedp != nil)
                 *cas->receivedp = false;
         if(cas->sg.elem != nil)
-                c->elemalg->copy(c->elemsize, cas->sg.elem, nil);
+                c->elemtype->alg->copy(c->elemsize, cas->sg.elem, nil);
         if(raceenabled)
                 runtime·raceacquire(c);
         goto retc;
 
 syncsend:
         // can send to sleeping receiver (sg)
-        if(raceenabled)
+        if(raceenabled) {
+                runtime·racereadobjectpc(cas->sg.elem, c->elemtype, cas->pc, runtime·chansend);
                 racesync(c, sg);
+        }
         selunlock(sel);
         if(debug)
                 runtime·printf("syncsend: sel=%p c=%p o=%d\n", sel, c, o);
         if(sg->elem != nil)
-                c->elemalg->copy(c->elemsize, sg->elem, cas->sg.elem);
+                c->elemtype->alg->copy(c->elemsize, sg->elem, cas->sg.elem);
         gp = sg->g;
         gp->param = sg;
         if(sg->releasetime)
                 sg->releasetime = runtime·cputicks();
         runtime·ready(gp);
 
 retc:
         // return pc corresponding to chosen case.
         // Set boolean passed during select creation
         // (at offset selp + cas->so) to true.
@@ skipping 216 matching lines @@
 }
 
 static void
 racesync(Hchan *c, SudoG *sg)
 {
         runtime·racerelease(chanbuf(c, 0));
         runtime·raceacquireg(sg->g, chanbuf(c, 0));
         runtime·racereleaseg(sg->g, chanbuf(c, 0));
         runtime·raceacquire(chanbuf(c, 0));
 }