Continue fighting pthreads.
Clean up thread library a bit too.
This commit is contained in:
rsc
parent
c6687d4591
commit
7966faa931
19 changed files with 539 additions and 654 deletions
|
|
@ -1,76 +1,59 @@
|
|||
#include <u.h>
|
||||
#include <signal.h>
|
||||
#include <errno.h>
|
||||
/*
|
||||
* Thread scheduler.
|
||||
*/
|
||||
#include "threadimpl.h"
|
||||
|
||||
static Thread *runthread(Proc*);
|
||||
|
||||
static char *_psstate[] = {
|
||||
"Dead",
|
||||
"Running",
|
||||
"Ready",
|
||||
"Rendezvous",
|
||||
};
|
||||
|
||||
static char*
|
||||
psstate(int s)
|
||||
{
|
||||
if(s < 0 || s >= nelem(_psstate))
|
||||
return "unknown";
|
||||
return _psstate[s];
|
||||
}
|
||||
static Thread *runthread(Proc*);
|
||||
static void schedexit(Proc*);
|
||||
|
||||
/*
|
||||
* Main scheduling loop.
|
||||
*/
|
||||
void
|
||||
needstack(int howmuch)
|
||||
{
|
||||
Proc *p;
|
||||
Thread *t;
|
||||
|
||||
p = _threadgetproc();
|
||||
if(p == nil || (t=p->thread) == nil)
|
||||
return;
|
||||
if((ulong)&howmuch < (ulong)t->stk+howmuch){ /* stack overflow waiting to happen */
|
||||
fprint(2, "stack overflow: stack at 0x%lux, limit at 0x%lux, need 0x%lux\n", (ulong)&p, (ulong)t->stk, howmuch);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
_scheduler(void *arg)
|
||||
_threadscheduler(void *arg)
|
||||
{
|
||||
Proc *p;
|
||||
Thread *t;
|
||||
|
||||
p = arg;
|
||||
lock(&p->lock);
|
||||
p->pid = _threadgetpid();
|
||||
_threadsetproc(p);
|
||||
|
||||
_threadlinkmain();
|
||||
_threadinitproc(p);
|
||||
|
||||
for(;;){
|
||||
/*
|
||||
* Clean up zombie children.
|
||||
*/
|
||||
_threadwaitkids(p);
|
||||
|
||||
/*
|
||||
* Find next thread to run.
|
||||
*/
|
||||
_threaddebug(DBGSCHED, "runthread");
|
||||
t = runthread(p);
|
||||
if(t == nil){
|
||||
_threaddebug(DBGSCHED, "all threads gone; exiting");
|
||||
_threaddelproc();
|
||||
_schedexit(p);
|
||||
}
|
||||
_threaddebug(DBGSCHED, "running %d.%d", t->proc->pid, t->id);
|
||||
p->thread = t;
|
||||
if(t->moribund){
|
||||
_threaddebug(DBGSCHED, "%d.%d marked to die");
|
||||
goto Moribund;
|
||||
}
|
||||
t->state = Running;
|
||||
t->nextstate = Ready;
|
||||
unlock(&p->lock);
|
||||
|
||||
_swaplabel(&p->sched, &t->sched);
|
||||
|
||||
if(t == nil)
|
||||
schedexit(p);
|
||||
|
||||
/*
|
||||
* If it's ready, run it (might instead be marked to die).
|
||||
*/
|
||||
lock(&p->lock);
|
||||
p->thread = nil;
|
||||
if(t->state == Ready){
|
||||
_threaddebug(DBGSCHED, "running %d.%d", p->id, t->id);
|
||||
t->state = Running;
|
||||
t->nextstate = Ready;
|
||||
p->thread = t;
|
||||
unlock(&p->lock);
|
||||
_swaplabel(&p->context, &t->context);
|
||||
lock(&p->lock);
|
||||
p->thread = nil;
|
||||
}
|
||||
|
||||
/*
|
||||
* If thread needs to die, kill it.
|
||||
*/
|
||||
if(t->moribund){
|
||||
Moribund:
|
||||
if(t->moribund != 1)
|
||||
fprint(2, "moribund %d\n", t->moribund);
|
||||
_threaddebug(DBGSCHED, "moribund %d.%d", p->id, t->id);
|
||||
assert(t->moribund == 1);
|
||||
t->state = Dead;
|
||||
if(t->prevt)
|
||||
|
|
@ -82,40 +65,37 @@ _scheduler(void *arg)
|
|||
else
|
||||
p->threads.tail = t->prevt;
|
||||
unlock(&p->lock);
|
||||
if(t->inrendez){
|
||||
abort();
|
||||
// _threadflagrendez(t);
|
||||
// _threadbreakrendez();
|
||||
}
|
||||
_stackfree(t->stk);
|
||||
free(t->cmdname);
|
||||
free(t); /* XXX how do we know there are no references? */
|
||||
_threadfree(t);
|
||||
p->nthreads--;
|
||||
t = nil;
|
||||
lock(&p->lock);
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
if(p->needexec){
|
||||
t->ret = _schedexec(&p->exec);
|
||||
p->needexec = 0;
|
||||
}
|
||||
*/
|
||||
if(p->newproc){
|
||||
t->ret = _schedfork(p->newproc);
|
||||
if(t->ret < 0){
|
||||
//fprint(2, "_schedfork: %r\n");
|
||||
abort();
|
||||
}
|
||||
p->newproc = nil;
|
||||
unlock(&p->lock);
|
||||
|
||||
/*
|
||||
* If there is a request to run a function on the
|
||||
* scheduling stack, do so.
|
||||
*/
|
||||
if(p->schedfn){
|
||||
_threaddebug(DBGSCHED, "schedfn");
|
||||
p->schedfn(p);
|
||||
p->schedfn = nil;
|
||||
_threaddebug(DBGSCHED, "schedfn ended");
|
||||
}
|
||||
|
||||
/*
|
||||
* Move the thread along.
|
||||
*/
|
||||
t->state = t->nextstate;
|
||||
_threaddebug(DBGSCHED, "moveon %d.%d", p->id, t->id);
|
||||
if(t->state == Ready)
|
||||
_threadready(t);
|
||||
unlock(&p->lock);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Called by thread to give up control of processor to scheduler.
|
||||
*/
|
||||
int
|
||||
_sched(void)
|
||||
{
|
||||
|
|
@ -125,146 +105,14 @@ _sched(void)
|
|||
p = _threadgetproc();
|
||||
t = p->thread;
|
||||
assert(t != nil);
|
||||
_swaplabel(&t->sched, &p->sched);
|
||||
_swaplabel(&t->context, &p->context);
|
||||
return p->nsched++;
|
||||
}
|
||||
|
||||
static Thread*
|
||||
runthread(Proc *p)
|
||||
{
|
||||
Channel *c;
|
||||
Thread *t;
|
||||
Tqueue *q;
|
||||
Waitmsg *w;
|
||||
int e, sent;
|
||||
|
||||
if(p->nthreads==0 || (p->nthreads==1 && p->idle))
|
||||
return nil;
|
||||
q = &p->ready;
|
||||
relock:
|
||||
lock(&p->readylock);
|
||||
if(p->nsched%128 == 0){
|
||||
/* clean up children */
|
||||
e = errno;
|
||||
if((c = _threadwaitchan) != nil){
|
||||
if(c->n <= c->s){
|
||||
sent = 0;
|
||||
for(;;){
|
||||
if((w = p->waitmsg) != nil)
|
||||
p->waitmsg = nil;
|
||||
else
|
||||
w = waitnohang();
|
||||
if(w == nil)
|
||||
break;
|
||||
if(sent == 0){
|
||||
unlock(&p->readylock);
|
||||
sent = 1;
|
||||
}
|
||||
if(nbsendp(c, w) != 1)
|
||||
break;
|
||||
}
|
||||
p->waitmsg = w;
|
||||
if(sent)
|
||||
goto relock;
|
||||
}
|
||||
}else{
|
||||
while((w = waitnohang()) != nil)
|
||||
free(w);
|
||||
}
|
||||
errno = e;
|
||||
}
|
||||
if(q->head == nil){
|
||||
if(p->idle){
|
||||
if(p->idle->state != Ready){
|
||||
fprint(2, "everyone is asleep\n");
|
||||
exits("everyone is asleep");
|
||||
}
|
||||
unlock(&p->readylock);
|
||||
_threaddebug(DBGSCHED, "running idle thread", p->nthreads);
|
||||
return p->idle;
|
||||
}
|
||||
|
||||
_threaddebug(DBGSCHED, "sleeping for more work (%d threads)", p->nthreads);
|
||||
q->asleep = 1;
|
||||
p->rend.l = &p->readylock;
|
||||
_procsleep(&p->rend);
|
||||
if(_threadexitsallstatus)
|
||||
_exits(_threadexitsallstatus);
|
||||
}
|
||||
t = q->head;
|
||||
q->head = t->next;
|
||||
unlock(&p->readylock);
|
||||
return t;
|
||||
}
|
||||
|
||||
long
|
||||
threadstack(void)
|
||||
{
|
||||
Proc *p;
|
||||
Thread *t;
|
||||
|
||||
p = _threadgetproc();
|
||||
t = p->thread;
|
||||
return (ulong)&p - (ulong)t->stk;
|
||||
}
|
||||
|
||||
void
|
||||
_threadready(Thread *t)
|
||||
{
|
||||
Tqueue *q;
|
||||
|
||||
if(t == t->proc->idle){
|
||||
_threaddebug(DBGSCHED, "idle thread is ready");
|
||||
return;
|
||||
}
|
||||
|
||||
assert(t->state == Ready);
|
||||
_threaddebug(DBGSCHED, "readying %d.%d", t->proc->pid, t->id);
|
||||
q = &t->proc->ready;
|
||||
lock(&t->proc->readylock);
|
||||
t->next = nil;
|
||||
if(q->head==nil)
|
||||
q->head = t;
|
||||
else
|
||||
q->tail->next = t;
|
||||
q->tail = t;
|
||||
if(q->asleep){
|
||||
assert(q->asleep == 1);
|
||||
q->asleep = 0;
|
||||
/* lock passes to runthread */
|
||||
_procwakeup(&t->proc->rend);
|
||||
}
|
||||
unlock(&t->proc->readylock);
|
||||
if(_threadexitsallstatus)
|
||||
_exits(_threadexitsallstatus);
|
||||
}
|
||||
|
||||
void
|
||||
_threadidle(void)
|
||||
{
|
||||
Tqueue *q;
|
||||
Thread *t, *idle;
|
||||
Proc *p;
|
||||
|
||||
p = _threadgetproc();
|
||||
q = &p->ready;
|
||||
lock(&p->readylock);
|
||||
assert(q->tail);
|
||||
idle = q->tail;
|
||||
if(q->head == idle){
|
||||
q->head = nil;
|
||||
q->tail = nil;
|
||||
}else{
|
||||
for(t=q->head; t->next!=q->tail; t=t->next)
|
||||
;
|
||||
t->next = nil;
|
||||
q->tail = t;
|
||||
}
|
||||
p->idle = idle;
|
||||
_threaddebug(DBGSCHED, "p->idle is %d\n", idle->id);
|
||||
unlock(&p->readylock);
|
||||
}
|
||||
|
||||
/*
|
||||
* Called by thread to yield the processor to other threads.
|
||||
* Returns number of other threads run between call and return.
|
||||
*/
|
||||
int
|
||||
yield(void)
|
||||
{
|
||||
|
|
@ -276,15 +124,176 @@ yield(void)
|
|||
return _sched() - nsched;
|
||||
}
|
||||
|
||||
void
|
||||
threadstatus(void)
|
||||
/*
|
||||
* Choose the next thread to run.
|
||||
*/
|
||||
static Thread*
|
||||
runthread(Proc *p)
|
||||
{
|
||||
Proc *p;
|
||||
Thread *t;
|
||||
Tqueue *q;
|
||||
|
||||
/*
|
||||
* No threads left?
|
||||
*/
|
||||
if(p->nthreads==0 || (p->nthreads==1 && p->idle))
|
||||
return nil;
|
||||
|
||||
lock(&p->readylock);
|
||||
q = &p->ready;
|
||||
if(q->head == nil){
|
||||
/*
|
||||
* Is this a single-process program with an idle thread?
|
||||
*/
|
||||
if(p->idle){
|
||||
/*
|
||||
* The idle thread had better be ready!
|
||||
*/
|
||||
if(p->idle->state != Ready)
|
||||
sysfatal("all threads are asleep");
|
||||
|
||||
/*
|
||||
* Run the idle thread.
|
||||
*/
|
||||
unlock(&p->readylock);
|
||||
_threaddebug(DBGSCHED, "running idle thread", p->nthreads);
|
||||
return p->idle;
|
||||
}
|
||||
|
||||
/*
|
||||
* Wait until one of our threads is readied (by another proc!).
|
||||
*/
|
||||
q->asleep = 1;
|
||||
p->rend.l = &p->readylock;
|
||||
_procsleep(&p->rend);
|
||||
|
||||
/*
|
||||
* Maybe we were awakened to exit?
|
||||
*/
|
||||
if(_threadexitsallstatus)
|
||||
_exits(_threadexitsallstatus);
|
||||
|
||||
assert(q->head != nil);
|
||||
}
|
||||
|
||||
t = q->head;
|
||||
q->head = t->next;
|
||||
unlock(&p->readylock);
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add a newly-ready thread to its proc's run queue.
|
||||
*/
|
||||
void
|
||||
_threadready(Thread *t)
|
||||
{
|
||||
Tqueue *q;
|
||||
|
||||
/*
|
||||
* The idle thread does not go on the run queue.
|
||||
*/
|
||||
if(t == t->proc->idle){
|
||||
_threaddebug(DBGSCHED, "idle thread is ready");
|
||||
return;
|
||||
}
|
||||
|
||||
assert(t->state == Ready);
|
||||
_threaddebug(DBGSCHED, "readying %d.%d", t->proc->id, t->id);
|
||||
|
||||
/*
|
||||
* Add thread to run queue.
|
||||
*/
|
||||
q = &t->proc->ready;
|
||||
lock(&t->proc->readylock);
|
||||
|
||||
t->next = nil;
|
||||
if(q->head == nil)
|
||||
q->head = t;
|
||||
else
|
||||
q->tail->next = t;
|
||||
q->tail = t;
|
||||
|
||||
/*
|
||||
* Wake proc scheduler if it is sleeping.
|
||||
*/
|
||||
if(q->asleep){
|
||||
assert(q->asleep == 1);
|
||||
q->asleep = 0;
|
||||
_procwakeup(&t->proc->rend);
|
||||
}
|
||||
unlock(&t->proc->readylock);
|
||||
}
|
||||
|
||||
/*
|
||||
* Mark the given thread as the idle thread.
|
||||
* Since the idle thread was just created, it is sitting
|
||||
* somewhere on the ready queue.
|
||||
*/
|
||||
void
|
||||
_threadsetidle(int id)
|
||||
{
|
||||
Tqueue *q;
|
||||
Thread *t, **l, *last;
|
||||
Proc *p;
|
||||
|
||||
p = _threadgetproc();
|
||||
for(t=p->threads.head; t; t=t->nextt)
|
||||
fprint(2, "[%3d] %s userpc=%lux\n",
|
||||
t->id, psstate(t->state), t->userpc);
|
||||
|
||||
lock(&p->readylock);
|
||||
|
||||
/*
|
||||
* Find thread on ready queue.
|
||||
*/
|
||||
q = &p->ready;
|
||||
for(l=&q->head, last=nil; (t=*l) != nil; l=&t->next, last=t)
|
||||
if(t->id == id)
|
||||
break;
|
||||
assert(t != nil);
|
||||
|
||||
/*
|
||||
* Remove it from ready queue.
|
||||
*/
|
||||
*l = t->next;
|
||||
if(t == q->head)
|
||||
q->head = t->next;
|
||||
if(t->next == nil)
|
||||
q->tail = last;
|
||||
|
||||
/*
|
||||
* Set as idle thread.
|
||||
*/
|
||||
p->idle = t;
|
||||
_threaddebug(DBGSCHED, "p->idle is %d\n", t->id);
|
||||
unlock(&p->readylock);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
schedexit(Proc *p)
|
||||
{
|
||||
char ex[ERRMAX];
|
||||
int n;
|
||||
Proc **l;
|
||||
|
||||
_threaddebug(DBGSCHED, "exiting proc %d", p->id);
|
||||
lock(&_threadpq.lock);
|
||||
for(l=&_threadpq.head; *l; l=&(*l)->next){
|
||||
if(*l == p){
|
||||
*l = p->next;
|
||||
if(*l == nil)
|
||||
_threadpq.tail = l;
|
||||
break;
|
||||
}
|
||||
}
|
||||
n = --_threadnprocs;
|
||||
unlock(&_threadpq.lock);
|
||||
|
||||
strncpy(ex, p->exitstr, sizeof ex);
|
||||
ex[sizeof ex-1] = '\0';
|
||||
free(p);
|
||||
if(n == 0)
|
||||
_threadexitallproc(ex);
|
||||
else
|
||||
_threadexitproc(ex);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue