void runtime·f32hash(uintptr *h, uintptr s, void *a) { uintptr hash; float32 f; USED(s); f = *(float32*)a; if(f == 0) hash = 0; // +0, -0 else if(f != f) hash = runtime·fastrand1(); // any kind of NaN else hash = *(uint32*)a; *h ^= (*h ^ hash ^ 2860486313U) * 3267000013U; }
void runtime·f32hash(uintptr *h, uintptr s, void *a) { uintptr hash; float32 f; USED(s); f = *(float32*)a; if(f == 0) hash = 0; // +0, -0 else if(f != f) hash = runtime·fastrand1(); // any kind of NaN else hash = *(uint32*)a; *h = (*h ^ hash ^ M0) * M1; }
runtime·allocmcache ( void ) { int32 rate; MCache *c; #line 2259 "C:\Go\src\pkg\runtime\malloc.goc" runtime·lock ( &runtime·mheap ) ; c = runtime·FixAlloc_Alloc ( &runtime·mheap.cachealloc ) ; mstats.mcache_inuse = runtime·mheap.cachealloc.inuse; mstats.mcache_sys = runtime·mheap.cachealloc.sys; runtime·unlock ( &runtime·mheap ) ; #line 2266 "C:\Go\src\pkg\runtime\malloc.goc" rate = runtime·MemProfileRate; if ( rate > 0x3fffffff ) rate = 0x3fffffff; if ( rate != 0 ) c->next_sample = runtime·fastrand1 ( ) % ( 2*rate ) ; #line 2272 "C:\Go\src\pkg\runtime\malloc.goc" return c; }
void runtime·f64hash(uintptr *h, uintptr s, void *a) { uintptr hash; float64 f; uint64 u; USED(s); f = *(float64*)a; if(f == 0) hash = 0; // +0, -0 else if(f != f) hash = runtime·fastrand1(); // any kind of NaN else { u = *(uint64*)a; if(sizeof(uintptr) == 4) hash = ((uint32)(u>>32) * 3267000013UL) ^ (uint32)u; else hash = u; }
static void hash_init ( MapType *t , Hmap *h , uint32 hint ) { uint8 B; byte *buckets; uintptr keysize , valuesize , bucketsize; uint8 flags; #line 98 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc" flags = 0; #line 101 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc" keysize = t->key->size; if ( keysize > MAXKEYSIZE ) { flags |= IndirectKey; keysize = sizeof ( byte* ) ; } valuesize = t->elem->size; if ( valuesize > MAXVALUESIZE ) { flags |= IndirectValue; valuesize = sizeof ( byte* ) ; } bucketsize = offsetof ( Bucket , data[0] ) + ( keysize + valuesize ) * BUCKETSIZE; if ( bucketsize != t->bucket->size ) { runtime·printf ( "runtime: bucketsize=%p but t->bucket->size=%p; t=%S\n" , bucketsize , t->bucket->size , *t->string ) ; runtime·throw ( "bucketsize wrong" ) ; } #line 119 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc" if ( t->key->align > BUCKETSIZE ) runtime·throw ( "key align too big" ) ; if ( t->elem->align > BUCKETSIZE ) runtime·throw ( "value align too big" ) ; if ( t->key->size % t->key->align != 0 ) runtime·throw ( "key size not a multiple of key align" ) ; if ( t->elem->size % t->elem->align != 0 ) runtime·throw ( "value size not a multiple of value align" ) ; if ( BUCKETSIZE < 8 ) runtime·throw ( "bucketsize too small for proper alignment" ) ; if ( ( offsetof ( Bucket , data[0] ) & ( t->key->align-1 ) ) != 0 ) runtime·throw ( "need padding in bucket (key)" ) ; if ( ( offsetof ( Bucket , data[0] ) & ( t->elem->align-1 ) ) != 0 ) runtime·throw ( "need padding in bucket (value)" ) ; #line 135 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc" B = 0; while ( hint > BUCKETSIZE && hint > LOAD * ( ( uintptr ) 1 << B ) ) B++; #line 141 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc" if ( checkgc ) mstats.next_gc = mstats.heap_alloc; if ( B == 0 ) { #line 144 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc" buckets = nil; } else { buckets = runtime·cnewarray ( t->bucket , ( uintptr ) 1 << B ) ; } #line 150 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc" h->count = 0; h->B = B; h->flags = flags; h->keysize = keysize; h->valuesize = valuesize; h->bucketsize = bucketsize; h->hash0 = runtime·fastrand1 ( ) ; h->buckets = buckets; h->oldbuckets = nil; h->nevacuate = 0; if ( docheck ) check ( t , h ) ; }
static void* selectgo ( Select **selp ) { Select *sel; uint32 o , i , j , k , done; int64 t0; Scase *cas , *dfl; Hchan *c; SudoG *sg; G *gp; byte *as; void *pc; #line 663 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" sel = *selp; #line 665 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( debug ) runtime·printf ( "select: sel=%p\n" , sel ) ; #line 668 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" t0 = 0; if ( runtime·blockprofilerate > 0 ) { t0 = runtime·cputicks ( ) ; for ( i=0; i<sel->ncase; i++ ) sel->scase[i].sg.releasetime = -1; } #line 684 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" for ( i=0; i<sel->ncase; i++ ) sel->pollorder[i] = i; for ( i=1; i<sel->ncase; i++ ) { o = sel->pollorder[i]; j = runtime·fastrand1 ( ) % ( i+1 ) ; sel->pollorder[i] = sel->pollorder[j]; sel->pollorder[j] = o; } #line 695 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" for ( i=0; i<sel->ncase; i++ ) { j = i; c = sel->scase[j].chan; while ( j > 0 && sel->lockorder[k= ( j-1 ) /2] < c ) { sel->lockorder[j] = sel->lockorder[k]; j = k; } sel->lockorder[j] = c; } for ( i=sel->ncase; i-->0; ) { c = sel->lockorder[i]; sel->lockorder[i] = sel->lockorder[0]; j = 0; for ( ;; ) { k = j*2+1; if ( k >= i ) break; if ( k+1 < i && sel->lockorder[k] < sel->lockorder[k+1] ) k++; if ( c < sel->lockorder[k] ) { sel->lockorder[j] = sel->lockorder[k]; j = k; continue; } break; } sel->lockorder[j] = c; } #line 730 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" sellock ( sel ) ; #line 732 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" loop: #line 734 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" dfl = nil; for ( i=0; i<sel->ncase; i++ ) { o = sel->pollorder[i]; cas = &sel->scase[o]; c = cas->chan; #line 740 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" switch ( cas->kind ) { case CaseRecv: if ( c->dataqsiz > 0 ) { if ( c->qcount > 0 ) goto asyncrecv; } else { sg = dequeue ( &c->sendq ) ; if ( sg != nil ) goto syncrecv; } if ( c->closed ) goto rclose; break; #line 754 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" case CaseSend: if ( raceenabled ) runtime·racereadpc ( c , cas->pc , chansend ) ; if ( c->closed ) goto sclose; if ( c->dataqsiz > 0 ) { if ( c->qcount < c->dataqsiz ) goto asyncsend; } else { sg = dequeue ( &c->recvq ) ; if ( sg != nil ) goto syncsend; } break; #line 769 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" case CaseDefault: dfl = cas; break; } } #line 775 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( dfl != nil ) { selunlock ( sel ) ; cas = dfl; goto retc; } #line 783 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" done = 0; for ( i=0; i<sel->ncase; i++ ) { o = sel->pollorder[i]; cas = &sel->scase[o]; c = cas->chan; sg = &cas->sg; sg->g = g; sg->selectdone = &done; #line 792 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" switch ( cas->kind ) { case CaseRecv: enqueue ( &c->recvq , sg ) ; break; #line 797 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" case CaseSend: enqueue ( &c->sendq , sg ) ; break; } } #line 803 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" g->param = nil; runtime·park ( selparkcommit , sel , "select" ) ; #line 806 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" sellock ( sel ) ; sg = g->param; #line 811 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" for ( i=0; i<sel->ncase; i++ ) { cas = &sel->scase[i]; if ( cas != ( Scase* ) sg ) { c = cas->chan; if ( cas->kind == CaseSend ) dequeueg ( &c->sendq ) ; else dequeueg ( &c->recvq ) ; } } #line 822 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( sg == nil ) goto loop; #line 825 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" cas = ( Scase* ) sg; c = cas->chan; #line 828 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( c->dataqsiz > 0 ) runtime·throw ( "selectgo: shouldn't happen" ) ; #line 831 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( debug ) runtime·printf ( "wait-return: sel=%p c=%p cas=%p kind=%d\n" , sel , c , cas , cas->kind ) ; #line 835 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( cas->kind == CaseRecv ) { if ( cas->receivedp != nil ) *cas->receivedp = true; } #line 840 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( raceenabled ) { if ( cas->kind == CaseRecv && cas->sg.elem != nil ) runtime·racewriteobjectpc ( cas->sg.elem , c->elemtype , cas->pc , chanrecv ) ; else if ( cas->kind == CaseSend ) runtime·racereadobjectpc ( cas->sg.elem , c->elemtype , cas->pc , chansend ) ; } #line 847 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" selunlock ( sel ) ; goto retc; #line 850 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" asyncrecv: #line 852 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( raceenabled ) { if ( cas->sg.elem != nil ) runtime·racewriteobjectpc ( cas->sg.elem , c->elemtype , cas->pc , chanrecv ) ; runtime·raceacquire ( chanbuf ( c , c->recvx ) ) ; runtime·racerelease ( chanbuf ( c , c->recvx ) ) ; } if ( cas->receivedp != nil ) *cas->receivedp = true; if ( cas->sg.elem != 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; #line 878 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" asyncsend: #line 880 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( raceenabled ) { runtime·raceacquire ( chanbuf ( c , c->sendx ) ) ; runtime·racerelease ( chanbuf ( c , c->sendx ) ) ; runtime·racereadobjectpc ( cas->sg.elem , c->elemtype , cas->pc , 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; #line 901 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" syncrecv: #line 903 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( raceenabled ) { if ( cas->sg.elem != nil ) runtime·racewriteobjectpc ( cas->sg.elem , c->elemtype , cas->pc , 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->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; #line 922 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" rclose: #line 924 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" selunlock ( sel ) ; if ( cas->receivedp != nil ) *cas->receivedp = false; if ( cas->sg.elem != nil ) c->elemtype->alg->copy ( c->elemsize , cas->sg.elem , nil ) ; if ( raceenabled ) runtime·raceacquire ( c ) ; goto retc; #line 933 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" syncsend: #line 935 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" if ( raceenabled ) { runtime·racereadobjectpc ( cas->sg.elem , c->elemtype , cas->pc , 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->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 ) ; #line 950 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" retc: #line 956 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" pc = cas->pc; if ( cas->so > 0 ) { as = ( byte* ) selp + cas->so; *as = true; } if ( cas->sg.releasetime > 0 ) runtime·blockevent ( cas->sg.releasetime - t0 , 2 ) ; runtime·free ( sel ) ; return pc; #line 966 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" sclose: #line 968 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc" selunlock ( sel ) ; runtime·panicstring ( "send on closed channel" ) ; return nil; }
static void* selectgo(Select **selp) { Select *sel; uint32 o, i, j; Scase *cas, *dfl; Hchan *c; SudoG *sg; G *gp; byte *as; void *pc; sel = *selp; if(runtime·gcwaiting) runtime·gosched(); if(debug) runtime·printf("select: sel=%p\n", sel); // The compiler rewrites selects that statically have // only 0 or 1 cases plus default into simpler constructs. // The only way we can end up with such small sel->ncase // values here is for a larger select in which most channels // have been nilled out. The general code handles those // cases correctly, and they are rare enough not to bother // optimizing (and needing to test). // generate permuted order for(i=0; i<sel->ncase; i++) sel->pollorder[i] = i; for(i=1; i<sel->ncase; i++) { o = sel->pollorder[i]; j = runtime·fastrand1()%(i+1); sel->pollorder[i] = sel->pollorder[j]; sel->pollorder[j] = o; } // sort the cases by Hchan address to get the locking order. for(i=0; i<sel->ncase; i++) { c = sel->scase[i].chan; for(j=i; j>0 && sel->lockorder[j-1] >= c; j--) sel->lockorder[j] = sel->lockorder[j-1]; sel->lockorder[j] = c; } sellock(sel); loop: // pass 1 - look for something already waiting dfl = nil; for(i=0; i<sel->ncase; i++) { o = sel->pollorder[i]; cas = &sel->scase[o]; c = cas->chan; switch(cas->kind) { case CaseRecv: if(c->dataqsiz > 0) { if(c->qcount > 0) goto asyncrecv; } else { sg = dequeue(&c->sendq); if(sg != nil) goto syncrecv; } if(c->closed) goto rclose; break; case CaseSend: if(c->closed) goto sclose; if(c->dataqsiz > 0) { if(c->qcount < c->dataqsiz) goto asyncsend; } else { sg = dequeue(&c->recvq); if(sg != nil) goto syncsend; } break; case CaseDefault: dfl = cas; break; } } if(dfl != nil) { selunlock(sel); cas = dfl; goto retc; } // pass 2 - enqueue on all chans for(i=0; i<sel->ncase; i++) { o = sel->pollorder[i]; cas = &sel->scase[o]; c = cas->chan; sg = &cas->sg; sg->g = g; sg->selgen = g->selgen; switch(cas->kind) { case CaseRecv: enqueue(&c->recvq, sg); break; case CaseSend: enqueue(&c->sendq, sg); break; } } g->param = nil; g->status = Gwaiting; g->waitreason = "select"; selunlock(sel); runtime·gosched(); sellock(sel); sg = g->param; // pass 3 - dequeue from unsuccessful chans // otherwise they stack up on quiet channels for(i=0; i<sel->ncase; i++) { cas = &sel->scase[i]; if(cas != (Scase*)sg) { c = cas->chan; if(cas->kind == CaseSend) dequeueg(&c->sendq); else dequeueg(&c->recvq); } } if(sg == nil) goto loop; cas = (Scase*)sg; c = cas->chan; if(c->dataqsiz > 0) runtime·throw("selectgo: shouldnt happen"); 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; } selunlock(sel); goto retc; asyncrecv: // can receive from buffer 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); if(++c->recvx == c->dataqsiz) c->recvx = 0; c->qcount--; sg = dequeue(&c->sendq); if(sg != nil) { gp = sg->g; selunlock(sel); runtime·ready(gp); } else { selunlock(sel); } goto retc; asyncsend: // can send to buffer c->elemalg->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); runtime·ready(gp); } else { selunlock(sel); } goto retc; syncrecv: // can receive from sleeping sender (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); gp = sg->g; gp->param = sg; 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); goto retc; syncsend: // can send to sleeping receiver (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); gp = sg->g; gp->param = sg; runtime·ready(gp); retc: // return to pc corresponding to chosen case pc = cas->pc; as = (byte*)selp + cas->so; runtime·free(sel); *as = true; return pc; sclose: // send on closed channel selunlock(sel); runtime·panicstring("send on closed channel"); return nil; // not reached }
runtime·mallocgc ( uintptr size , uint32 flag , int32 dogc , int32 zeroed ) { int32 sizeclass , rate; MCache *c; uintptr npages; MSpan *s; void *v; #line 2080 "C:\Go\src\pkg\runtime\malloc.goc" if ( runtime·gcwaiting && g != m->g0 && m->locks == 0 ) runtime·gosched ( ) ; if ( m->mallocing ) runtime·throw ( "malloc/free - deadlock" ) ; m->mallocing = 1; if ( size == 0 ) size = 1; #line 2088 "C:\Go\src\pkg\runtime\malloc.goc" c = m->mcache; c->local_nmalloc++; if ( size <= MaxSmallSize ) { #line 2092 "C:\Go\src\pkg\runtime\malloc.goc" sizeclass = runtime·SizeToClass ( size ) ; size = runtime·class_to_size[sizeclass]; v = runtime·MCache_Alloc ( c , sizeclass , size , zeroed ) ; if ( v == nil ) runtime·throw ( "out of memory" ) ; c->local_alloc += size; c->local_total_alloc += size; c->local_by_size[sizeclass].nmalloc++; } else { #line 2104 "C:\Go\src\pkg\runtime\malloc.goc" npages = size >> PageShift; if ( ( size & PageMask ) != 0 ) npages++; s = runtime·MHeap_Alloc ( &runtime·mheap , npages , 0 , 1 ) ; if ( s == nil ) runtime·throw ( "out of memory" ) ; size = npages<<PageShift; c->local_alloc += size; c->local_total_alloc += size; v = ( void* ) ( s->start << PageShift ) ; #line 2116 "C:\Go\src\pkg\runtime\malloc.goc" runtime·markspan ( v , 0 , 0 , true ) ; } if ( ! ( flag & FlagNoGC ) ) runtime·markallocated ( v , size , ( flag&FlagNoPointers ) != 0 ) ; #line 2121 "C:\Go\src\pkg\runtime\malloc.goc" m->mallocing = 0; #line 2123 "C:\Go\src\pkg\runtime\malloc.goc" if ( ! ( flag & FlagNoProfiling ) && ( rate = runtime·MemProfileRate ) > 0 ) { if ( size >= rate ) goto profile; if ( m->mcache->next_sample > size ) m->mcache->next_sample -= size; else { #line 2131 "C:\Go\src\pkg\runtime\malloc.goc" if ( rate > 0x3fffffff ) rate = 0x3fffffff; m->mcache->next_sample = runtime·fastrand1 ( ) % ( 2*rate ) ; profile: runtime·setblockspecial ( v , true ) ; runtime·MProf_Malloc ( v , size ) ; } } #line 2140 "C:\Go\src\pkg\runtime\malloc.goc" if ( dogc && mstats.heap_alloc >= mstats.next_gc ) runtime·gc ( 0 ) ; return v; }
static void* selectgo(Select **selp) { Select *sel; uint32 o, i, j, k; Scase *cas, *dfl; Hchan *c; SudoG *sg; G *gp; byte *as; void *pc; sel = *selp; if(runtime·gcwaiting) runtime·gosched(); if(debug) runtime·printf("select: sel=%p\n", sel); // The compiler rewrites selects that statically have // only 0 or 1 cases plus default into simpler constructs. // The only way we can end up with such small sel->ncase // values here is for a larger select in which most channels // have been nilled out. The general code handles those // cases correctly, and they are rare enough not to bother // optimizing (and needing to test). // generate permuted order for(i=0; i<sel->ncase; i++) sel->pollorder[i] = i; for(i=1; i<sel->ncase; i++) { o = sel->pollorder[i]; j = runtime·fastrand1()%(i+1); sel->pollorder[i] = sel->pollorder[j]; sel->pollorder[j] = o; } // sort the cases by Hchan address to get the locking order. // simple heap sort, to guarantee n log n time and constant stack footprint. for(i=0; i<sel->ncase; i++) { j = i; c = sel->scase[j].chan; while(j > 0 && sel->lockorder[k=(j-1)/2] < c) { sel->lockorder[j] = sel->lockorder[k]; j = k; } sel->lockorder[j] = c; } for(i=sel->ncase; i-->0; ) { c = sel->lockorder[i]; sel->lockorder[i] = sel->lockorder[0]; j = 0; for(;;) { k = j*2+1; if(k >= i) break; if(k+1 < i && sel->lockorder[k] < sel->lockorder[k+1]) k++; if(c < sel->lockorder[k]) { sel->lockorder[j] = sel->lockorder[k]; j = k; continue; } break; } sel->lockorder[j] = c; } /* for(i=0; i+1<sel->ncase; i++) if(sel->lockorder[i] > sel->lockorder[i+1]) { runtime·printf("i=%d %p %p\n", i, sel->lockorder[i], sel->lockorder[i+1]); runtime·throw("select: broken sort"); } */ sellock(sel); loop: // pass 1 - look for something already waiting dfl = nil; for(i=0; i<sel->ncase; i++) { o = sel->pollorder[i]; cas = &sel->scase[o]; c = cas->chan; switch(cas->kind) { case CaseRecv: if(c->dataqsiz > 0) { if(c->qcount > 0) goto asyncrecv; } else { sg = dequeue(&c->sendq); if(sg != nil) goto syncrecv; } if(c->closed) goto rclose; break; case CaseSend: if(c->closed) goto sclose; if(c->dataqsiz > 0) { if(c->qcount < c->dataqsiz) goto asyncsend; } else { sg = dequeue(&c->recvq); if(sg != nil) goto syncsend; } break; case CaseDefault: dfl = cas; break; } } if(dfl != nil) { selunlock(sel); cas = dfl; goto retc; } // pass 2 - enqueue on all chans for(i=0; i<sel->ncase; i++) { o = sel->pollorder[i]; cas = &sel->scase[o]; c = cas->chan; sg = &cas->sg; sg->g = g; sg->selgen = g->selgen; switch(cas->kind) { case CaseRecv: enqueue(&c->recvq, sg); break; case CaseSend: enqueue(&c->sendq, sg); break; } } g->param = nil; runtime·park((void(*)(Lock*))selunlock, (Lock*)sel, "select"); sellock(sel); sg = g->param; // pass 3 - dequeue from unsuccessful chans // otherwise they stack up on quiet channels for(i=0; i<sel->ncase; i++) { cas = &sel->scase[i]; if(cas != (Scase*)sg) { c = cas->chan; if(cas->kind == CaseSend) dequeueg(&c->sendq); else dequeueg(&c->recvq); } } if(sg == nil) goto loop; cas = (Scase*)sg; c = cas->chan; if(c->dataqsiz > 0) runtime·throw("selectgo: shouldn't happen"); 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; } selunlock(sel); goto retc; asyncrecv: // can receive from buffer if(raceenabled) 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); if(++c->recvx == c->dataqsiz) c->recvx = 0; c->qcount--; sg = dequeue(&c->sendq); if(sg != nil) { gp = sg->g; selunlock(sel); runtime·ready(gp); } else { selunlock(sel); } goto retc; asyncsend: // can send to buffer if(raceenabled) runtime·racerelease(chanbuf(c, c->sendx)); c->elemalg->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); runtime·ready(gp); } else { selunlock(sel); } goto retc; syncrecv: // can receive from sleeping sender (sg) if(raceenabled) 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); gp = sg->g; gp->param = sg; 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); if(raceenabled) runtime·raceacquire(c); goto retc; syncsend: // can send to sleeping receiver (sg) if(raceenabled) 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); gp = sg->g; gp->param = sg; runtime·ready(gp); retc: // return pc corresponding to chosen case. // Set boolean passed during select creation // (at offset selp + cas->so) to true. // If cas->so == 0, this is a reflect-driven select and we // don't need to update the boolean. pc = cas->pc; if(cas->so > 0) { as = (byte*)selp + cas->so; *as = true; } runtime·free(sel); return pc; sclose: // send on closed channel selunlock(sel); runtime·panicstring("send on closed channel"); return nil; // not reached }