int64
runtime·tickspersecond(void)
{
int64 res, t0, t1, c0, c1;
res = (int64)runtime·atomicload64((uint64*)&ticks);
if(res != 0)
return ticks;
runtime·lock(&ticksLock);
res = ticks;
if(res == 0) {
t0 = runtime·nanotime();
c0 = runtime·cputicks();
runtime·usleep(100*1000);
t1 = runtime·nanotime();
c1 = runtime·cputicks();
if(t1 == t0)
t1++;
res = (c1-c0)*1000*1000*1000/(t1-t0);
if(res == 0)
res++;
runtime·atomicstore64((uint64*)&ticks, res);
}
runtime·unlock(&ticksLock);
return res;
}
static void
closechan ( Hchan *c , void *pc )
{
SudoG *sg;
G* gp;
#line 1041 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( c == nil )
runtime·panicstring ( "close of nil channel" ) ;
#line 1044 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
runtime·lock ( c ) ;
if ( c->closed ) {
runtime·unlock ( c ) ;
runtime·panicstring ( "close of closed channel" ) ;
}
#line 1050 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( raceenabled ) {
runtime·racewritepc ( c , pc , runtime·closechan ) ;
runtime·racerelease ( c ) ;
}
#line 1055 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
c->closed = true;
#line 1058 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
for ( ;; ) {
sg = dequeue ( &c->recvq ) ;
if ( sg == nil )
break;
gp = sg->g;
gp->param = nil;
if ( sg->releasetime )
sg->releasetime = runtime·cputicks ( ) ;
runtime·ready ( gp ) ;
}
#line 1070 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
for ( ;; ) {
sg = dequeue ( &c->sendq ) ;
if ( sg == nil )
break;
gp = sg->g;
gp->param = nil;
if ( sg->releasetime )
sg->releasetime = runtime·cputicks ( ) ;
runtime·ready ( gp ) ;
}
#line 1081 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
runtime·unlock ( c ) ;
}
static void
closechan ( Hchan *c , void *pc )
{
SudoG *sg;
G* gp;
#line 1045 "/home/14/ren/source/golang/go/src/pkg/runtime/chan.goc"
if ( c == nil )
runtime·panicstring ( "close of nil channel" ) ;
#line 1048 "/home/14/ren/source/golang/go/src/pkg/runtime/chan.goc"
runtime·lock ( c ) ;
if ( c->closed ) {
runtime·unlock ( c ) ;
runtime·panicstring ( "close of closed channel" ) ;
}
#line 1054 "/home/14/ren/source/golang/go/src/pkg/runtime/chan.goc"
if ( raceenabled ) {
runtime·racewritepc ( c , pc , runtime·closechan ) ;
runtime·racerelease ( c ) ;
}
#line 1059 "/home/14/ren/source/golang/go/src/pkg/runtime/chan.goc"
c->closed = true;
#line 1062 "/home/14/ren/source/golang/go/src/pkg/runtime/chan.goc"
for ( ;; ) {
sg = dequeue ( &c->recvq ) ;
if ( sg == nil )
break;
gp = sg->g;
gp->param = nil;
if ( sg->releasetime )
sg->releasetime = runtime·cputicks ( ) ;
runtime·ready ( gp ) ;
}
#line 1074 "/home/14/ren/source/golang/go/src/pkg/runtime/chan.goc"
for ( ;; ) {
sg = dequeue ( &c->sendq ) ;
if ( sg == nil )
break;
gp = sg->g;
gp->param = nil;
if ( sg->releasetime )
sg->releasetime = runtime·cputicks ( ) ;
runtime·ready ( gp ) ;
}
#line 1085 "/home/14/ren/source/golang/go/src/pkg/runtime/chan.goc"
runtime·unlock ( c ) ;
}
int main (int argc, char *argvp[])
{
tick_t i;
tick_t start;
tick_t delta;
// printf("%lld\n", cputicks());
// printf("%lld\n", cputicks());
start = cputicks();
for (i = 0; i < 400017LL; i++) {
delta = cputicks() - start;
start = cputicks();
cascade(delta);
}
pr_cascade();
return 0;
}
static void
mcommoninit(M *mp)
{
mp->id = runtime·sched.mcount++;
mp->fastrand = 0x49f6428aUL + mp->id + runtime·cputicks();
if(mp->mcache == nil)
mp->mcache = runtime·allocmcache();
runtime·callers(1, mp->createstack, nelem(mp->createstack));
// Add to runtime·allm so garbage collector doesn't free m
// when it is just in a register or thread-local storage.
mp->alllink = runtime·allm;
// runtime·NumCgoCall() iterates over allm w/o schedlock,
// so we need to publish it safely.
runtime·atomicstorep(&runtime·allm, mp);
}
static void
mcommoninit(M *m)
{
m->id = runtime·sched.mcount++;
m->fastrand = 0x49f6428aUL + m->id + runtime·cputicks();
m->stackalloc = runtime·malloc(sizeof(*m->stackalloc));
runtime·FixAlloc_Init(m->stackalloc, FixedStack, runtime·SysAlloc, nil, nil);
if(m->mcache == nil)
m->mcache = runtime·allocmcache();
runtime·callers(1, m->createstack, nelem(m->createstack));
// Add to runtime·allm so garbage collector doesn't free m
// when it is just in a register or thread-local storage.
m->alllink = runtime·allm;
// runtime·NumCgoCall() iterates over allm w/o schedlock,
// so we need to publish it safely.
runtime·atomicstorep(&runtime·allm, m);
}
static void print_procs(int maxlines,
struct proc *proc1, struct proc *proc2, int cputimemode)
{
int p, nprocs;
u64_t idleticks = 0;
u64_t kernelticks = 0;
u64_t systemticks = 0;
u64_t userticks = 0;
u64_t total_ticks = 0;
int blockedseen = 0;
static struct tp *tick_procs = NULL;
if (tick_procs == NULL) {
tick_procs = malloc(nr_total * sizeof(tick_procs[0]));
if (tick_procs == NULL) {
fprintf(stderr, "Out of memory!\n");
exit(1);
}
}
for(p = nprocs = 0; p < nr_total; p++) {
u64_t uticks;
if(!(proc2[p].p_flags & USED))
continue;
tick_procs[nprocs].p = proc2 + p;
tick_procs[nprocs].ticks = cputicks(&proc1[p], &proc2[p], cputimemode);
uticks = cputicks(&proc1[p], &proc2[p], 1);
total_ticks = total_ticks + uticks;
if(p-NR_TASKS == IDLE) {
idleticks = uticks;
continue;
}
if(p-NR_TASKS == KERNEL) {
kernelticks = uticks;
}
if(!(proc2[p].p_flags & IS_TASK)) {
if(proc2[p].p_flags & IS_SYSTEM)
systemticks = systemticks + tick_procs[nprocs].ticks;
else
userticks = userticks + tick_procs[nprocs].ticks;
}
nprocs++;
}
if (total_ticks == 0)
return;
qsort(tick_procs, nprocs, sizeof(tick_procs[0]), cmp_procs);
printf("CPU states: %6.2f%% user, ", 100.0 * userticks / total_ticks);
printf("%6.2f%% system, ", 100.0 * systemticks / total_ticks);
printf("%6.2f%% kernel, ", 100.0 * kernelticks/ total_ticks);
printf("%6.2f%% idle", 100.0 * idleticks / total_ticks);
#define NEWLINE do { printf("\n"); if(--maxlines <= 0) { return; } } while(0)
NEWLINE;
printf("CPU time displayed ('%c' to cycle): %s; ",
TIMECYCLEKEY, cputimemodename(cputimemode));
printf(" sort order ('%c' to cycle): %s", ORDERKEY, ordername(order));
NEWLINE;
NEWLINE;
printf(" PID USERNAME PRI NICE SIZE STATE TIME CPU COMMAND");
NEWLINE;
for(p = 0; p < nprocs; p++) {
struct proc *pr;
int level = 0;
pr = tick_procs[p].p;
if((pr->p_flags & IS_TASK) && pr->p_pid != KERNEL) {
/* skip old kernel tasks as they don't run anymore */
continue;
}
/* If we're in blocked verbose mode, indicate start of
* blocked processes.
*/
if(blockedverbose && (pr->p_flags & BLOCKED) && !blockedseen) {
NEWLINE;
printf("Blocked processes:");
NEWLINE;
blockedseen = 1;
}
print_proc(&tick_procs[p], total_ticks);
NEWLINE;
if(!blockedverbose)
continue;
/* Traverse dependency chain if blocked. */
while(pr->p_flags & BLOCKED) {
endpoint_t dep = NONE;
struct tp *tpdep;
level += 5;
if((dep = pr->p_blocked) == NONE) {
printf("not blocked on a process");
NEWLINE;
break;
}
if(dep == ANY)
break;
tpdep = lookup(dep, tick_procs, nprocs);
pr = tpdep->p;
printf("%*s> ", level, "");
print_proc(tpdep, total_ticks);
NEWLINE;
}
}
}
static bool
chansend ( ChanType *t , Hchan *c , byte *ep , bool block , void *pc )
{
SudoG *sg;
SudoG mysg;
G* gp;
int64 t0;
#line 82 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( raceenabled )
runtime·racereadobjectpc ( ep , t->elem , runtime·getcallerpc ( &t ) , chansend ) ;
#line 85 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( c == nil ) {
USED ( t ) ;
if ( !block )
return false;
runtime·park ( nil , nil , "chan send (nil chan)" ) ;
return false;
}
#line 93 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( debug ) {
runtime·printf ( "chansend: chan=%p; elem=" , c ) ;
c->elemtype->alg->print ( c->elemsize , ep ) ;
runtime·prints ( "\n" ) ;
}
#line 99 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
t0 = 0;
mysg.releasetime = 0;
if ( runtime·blockprofilerate > 0 ) {
t0 = runtime·cputicks ( ) ;
mysg.releasetime = -1;
}
#line 106 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
runtime·lock ( c ) ;
if ( raceenabled )
runtime·racereadpc ( c , pc , chansend ) ;
if ( c->closed )
goto closed;
#line 112 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( c->dataqsiz > 0 )
goto asynch;
#line 115 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
sg = dequeue ( &c->recvq ) ;
if ( sg != nil ) {
if ( raceenabled )
racesync ( c , sg ) ;
runtime·unlock ( c ) ;
#line 121 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
gp = sg->g;
gp->param = sg;
if ( sg->elem != nil )
c->elemtype->alg->copy ( c->elemsize , sg->elem , ep ) ;
if ( sg->releasetime )
sg->releasetime = runtime·cputicks ( ) ;
runtime·ready ( gp ) ;
return true;
}
#line 131 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( !block ) {
runtime·unlock ( c ) ;
return false;
}
#line 136 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
mysg.elem = ep;
mysg.g = g;
mysg.selectdone = nil;
g->param = nil;
enqueue ( &c->sendq , &mysg ) ;
runtime·parkunlock ( c , "chan send" ) ;
#line 143 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( g->param == nil ) {
runtime·lock ( c ) ;
if ( !c->closed )
runtime·throw ( "chansend: spurious wakeup" ) ;
goto closed;
}
#line 150 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( mysg.releasetime > 0 )
runtime·blockevent ( mysg.releasetime - t0 , 2 ) ;
#line 153 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
return true;
#line 155 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
asynch:
if ( c->closed )
goto closed;
#line 159 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( c->qcount >= c->dataqsiz ) {
if ( !block ) {
runtime·unlock ( c ) ;
return false;
}
mysg.g = g;
mysg.elem = nil;
mysg.selectdone = nil;
enqueue ( &c->sendq , &mysg ) ;
runtime·parkunlock ( c , "chan send" ) ;
#line 170 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
runtime·lock ( c ) ;
goto asynch;
}
#line 174 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( raceenabled ) {
runtime·raceacquire ( chanbuf ( c , c->sendx ) ) ;
runtime·racerelease ( chanbuf ( c , c->sendx ) ) ;
}
#line 179 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
c->elemtype->alg->copy ( c->elemsize , chanbuf ( c , c->sendx ) , ep ) ;
if ( ++c->sendx == c->dataqsiz )
c->sendx = 0;
c->qcount++;
#line 184 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
sg = dequeue ( &c->recvq ) ;
if ( sg != nil ) {
gp = sg->g;
runtime·unlock ( c ) ;
if ( sg->releasetime )
sg->releasetime = runtime·cputicks ( ) ;
runtime·ready ( gp ) ;
} else
runtime·unlock ( c ) ;
if ( mysg.releasetime > 0 )
runtime·blockevent ( mysg.releasetime - t0 , 2 ) ;
return true;
#line 197 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
closed:
runtime·unlock ( c ) ;
runtime·panicstring ( "send on closed channel" ) ;
return false;
}
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 bool
chanrecv ( ChanType *t , Hchan* c , byte *ep , bool block , bool *received )
{
SudoG *sg;
SudoG mysg;
G *gp;
int64 t0;
#line 214 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( debug )
runtime·printf ( "chanrecv: chan=%p\n" , c ) ;
#line 217 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( c == nil ) {
USED ( t ) ;
if ( !block )
return false;
runtime·park ( nil , nil , "chan receive (nil chan)" ) ;
return false;
}
#line 225 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
t0 = 0;
mysg.releasetime = 0;
if ( runtime·blockprofilerate > 0 ) {
t0 = runtime·cputicks ( ) ;
mysg.releasetime = -1;
}
#line 232 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
runtime·lock ( c ) ;
if ( c->dataqsiz > 0 )
goto asynch;
#line 236 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( c->closed )
goto closed;
#line 239 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
sg = dequeue ( &c->sendq ) ;
if ( sg != nil ) {
if ( raceenabled )
racesync ( c , sg ) ;
runtime·unlock ( c ) ;
#line 245 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( ep != nil )
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 ) ;
#line 253 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( received != nil )
*received = true;
return true;
}
#line 258 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( !block ) {
runtime·unlock ( c ) ;
return false;
}
#line 263 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
mysg.elem = ep;
mysg.g = g;
mysg.selectdone = nil;
g->param = nil;
enqueue ( &c->recvq , &mysg ) ;
runtime·parkunlock ( c , "chan receive" ) ;
#line 270 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( g->param == nil ) {
runtime·lock ( c ) ;
if ( !c->closed )
runtime·throw ( "chanrecv: spurious wakeup" ) ;
goto closed;
}
#line 277 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( received != nil )
*received = true;
if ( mysg.releasetime > 0 )
runtime·blockevent ( mysg.releasetime - t0 , 2 ) ;
return true;
#line 283 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
asynch:
if ( c->qcount <= 0 ) {
if ( c->closed )
goto closed;
#line 288 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( !block ) {
runtime·unlock ( c ) ;
if ( received != nil )
*received = false;
return false;
}
mysg.g = g;
mysg.elem = nil;
mysg.selectdone = nil;
enqueue ( &c->recvq , &mysg ) ;
runtime·parkunlock ( c , "chan receive" ) ;
#line 300 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
runtime·lock ( c ) ;
goto asynch;
}
#line 304 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( raceenabled ) {
runtime·raceacquire ( chanbuf ( c , c->recvx ) ) ;
runtime·racerelease ( chanbuf ( c , c->recvx ) ) ;
}
#line 309 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( ep != 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--;
#line 316 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
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 ) ;
#line 326 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
if ( received != nil )
*received = true;
if ( mysg.releasetime > 0 )
runtime·blockevent ( mysg.releasetime - t0 , 2 ) ;
return true;
#line 332 "/tmp/makerelease402042453/go/src/pkg/runtime/chan.goc"
closed:
if ( ep != nil )
c->elemtype->alg->copy ( c->elemsize , ep , nil ) ;
if ( received != nil )
*received = false;
if ( raceenabled )
runtime·raceacquire ( c ) ;
runtime·unlock ( c ) ;
if ( mysg.releasetime > 0 )
runtime·blockevent ( mysg.releasetime - t0 , 2 ) ;
return true;
}
void
runtime·chanrecv(ChanType *t, Hchan* c, byte *ep, bool *selected, bool *received)
{
SudoG *sg;
SudoG mysg;
G *gp;
int64 t0;
if(runtime·gcwaiting)
runtime·gosched();
if(debug)
runtime·printf("chanrecv: chan=%p\n", c);
if(c == nil) {
USED(t);
if(selected != nil) {
*selected = false;
return;
}
runtime·park(nil, nil, "chan receive (nil chan)");
return; // not reached
}
t0 = 0;
mysg.releasetime = 0;
if(runtime·blockprofilerate > 0) {
t0 = runtime·cputicks();
mysg.releasetime = -1;
}
runtime·lock(c);
if(c->dataqsiz > 0)
goto asynch;
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);
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;
return;
}
if(selected != nil) {
runtime·unlock(c);
*selected = false;
return;
}
mysg.elem = ep;
mysg.g = g;
mysg.selgen = NOSELGEN;
g->param = nil;
enqueue(&c->recvq, &mysg);
runtime·park(runtime·unlock, c, "chan receive");
if(g->param == nil) {
runtime·lock(c);
if(!c->closed)
runtime·throw("chanrecv: spurious wakeup");
goto closed;
}
if(received != nil)
*received = true;
if(mysg.releasetime > 0)
runtime·blockevent(mysg.releasetime - t0, 2);
return;
asynch:
if(c->qcount <= 0) {
if(c->closed)
goto closed;
if(selected != nil) {
runtime·unlock(c);
*selected = false;
if(received != nil)
*received = false;
return;
}
mysg.g = g;
mysg.elem = nil;
mysg.selgen = NOSELGEN;
enqueue(&c->recvq, &mysg);
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);
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);
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);
}
/*
* generic single channel send/recv
* if the bool pointer is nil,
* then the full exchange will
* occur. if pres is not nil,
* then the protocol will not
* sleep but return if it could
* not complete.
*
* sleep can wake up with g->param == nil
* when a channel involved in the sleep has
* been closed. it is easiest to loop and re-run
* the operation; we'll see that it's now closed.
*/
void
runtime·chansend(ChanType *t, Hchan *c, byte *ep, bool *pres, void *pc)
{
SudoG *sg;
SudoG mysg;
G* gp;
int64 t0;
if(c == nil) {
USED(t);
if(pres != nil) {
*pres = false;
return;
}
runtime·park(nil, nil, "chan send (nil chan)");
return; // not reached
}
if(runtime·gcwaiting)
runtime·gosched();
if(debug) {
runtime·printf("chansend: chan=%p; elem=", c);
c->elemalg->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);
// TODO(dvyukov): add similar instrumentation to select.
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);
if(sg->releasetime)
sg->releasetime = runtime·cputicks();
runtime·ready(gp);
if(pres != nil)
*pres = true;
return;
}
if(pres != nil) {
runtime·unlock(c);
*pres = false;
return;
}
mysg.elem = ep;
mysg.g = g;
mysg.selgen = NOSELGEN;
g->param = nil;
enqueue(&c->sendq, &mysg);
runtime·park(runtime·unlock, c, "chan send");
if(g->param == nil) {
runtime·lock(c);
if(!c->closed)
runtime·throw("chansend: spurious wakeup");
goto closed;
}
if(mysg.releasetime > 0)
runtime·blockevent(mysg.releasetime - t0, 2);
return;
asynch:
if(c->closed)
goto closed;
if(c->qcount >= c->dataqsiz) {
if(pres != nil) {
runtime·unlock(c);
*pres = false;
return;
}
mysg.g = g;
mysg.elem = nil;
mysg.selgen = NOSELGEN;
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);
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();
runtime·ready(gp);
} else
runtime·unlock(c);
if(pres != nil)
*pres = true;
if(mysg.releasetime > 0)
runtime·blockevent(mysg.releasetime - t0, 2);
return;
closed:
runtime·unlock(c);
runtime·panicstring("send on closed channel");
}