Subversion Repositories planix.SVN

#pragma src "/sys/src/libthread"

#pragma lib "libthread.a"

#pragma	varargck	argpos	chanprint	2

typedef struct Alt	Alt;

typedef struct Channel	Channel;

typedef struct Ref	Ref;

/*

 * Channel structure.  S is the size of the buffer.  For unbuffered channels

 * s is zero.  v is an array of s values.  If s is zero, v is unused.

 * f and n represent the state of the queue pointed to by v.

 */

enum {

	Nqwds = 2,

	Nqshift = 5,		/* log₂ # of bits in long */

	Nqmask =  -1,

	Nqbits = (1 << Nqshift) * 2,

};

struct Channel {

	int	s;		/* Size of the channel (may be zero) */

	uint	f;		/* Extraction point (insertion pt: (f+n) % s) */

	uint	n;		/* Number of values in the channel */

	int	e;		/* Element size */

	int	freed;		/* Set when channel is being deleted */

	volatile Alt **qentry;	/* Receivers/senders waiting (malloc) */

	volatile int nentry;	/* # of entries malloc-ed */

	volatile int closed;	/* channel is closed */

	uchar	v[1];		/* Array of s values in the channel */

};

/* Channel operations for alt: */

typedef enum {

	CHANEND,

	CHANSND,

	CHANRCV,

	CHANNOP,

	CHANNOBLK,

} ChanOp;

struct Alt {

	Channel	*c;		/* channel */

	void	*v;		/* pointer to value */

	ChanOp	op;		/* operation */

	char	*err;		/* did the op fail? */

	/*

	 * the next variables are used internally to alt

	 * they need not be initialized

	 */

	Channel	**tag;		/* pointer to rendez-vous tag */

	int	entryno;	/* entry number */

};

struct Ref {

	long	ref;

};

int	alt(Alt alts[]);

int	chanclose(Channel*);

int	chanclosing(Channel *c);

Channel*chancreate(int elemsize, int bufsize);

int	chaninit(Channel *c, int elemsize, int elemcnt);

void	chanfree(Channel *c);

int	chanprint(Channel *, char *, ...);

long	decref(Ref *r);			/* returns 0 iff value is now zero */

void	incref(Ref *r);

int	nbrecv(Channel *c, void *v);

void*	nbrecvp(Channel *c);

ulong	nbrecvul(Channel *c);

int	nbsend(Channel *c, void *v);

int	nbsendp(Channel *c, void *v);

int	nbsendul(Channel *c, ulong v);

void	needstack(int);

int	proccreate(void (*f)(void *arg), void *arg, uint stacksize);

int	procrfork(void (*f)(void *arg), void *arg, uint stacksize, int flag);

void**	procdata(void);

void	procexec(Channel *, char *, char *[]);

void	procexecl(Channel *, char *, ...);

int	recv(Channel *c, void *v);

void*	recvp(Channel *c);

ulong	recvul(Channel *c);

int	send(Channel *c, void *v);

int	sendp(Channel *c, void *v);

int	sendul(Channel *c, ulong v);

int	threadcreate(void (*f)(void *arg), void *arg, uint stacksize);

void**	threaddata(void);

void	threadexits(char *);

void	threadexitsall(char *);

int	threadgetgrp(void);	/* return thread group of current thread */

char*	threadgetname(void);

void	threadint(int);		/* interrupt thread */

void	threadintgrp(int);	/* interrupt threads in grp */

void	threadkill(int);	/* kill thread */

void	threadkillgrp(int);	/* kill threads in group */

void	threadmain(int argc, char *argv[]);

void	threadnonotes(void);

int	threadnotify(int (*f)(void*, char*), int in);

int	threadid(void);

int	threadpid(int);

int	threadsetgrp(int);		/* set thread group, return old */

void	threadsetname(char *fmt, ...);

Channel*threadwaitchan(void);

int	tprivalloc(void);

void	tprivfree(int);

void	**tprivaddr(int);

void	yield(void);

extern	int	mainstacksize;

/* slave I/O processes */

typedef struct Ioproc Ioproc;

#pragma incomplete Ioproc

Ioproc*	ioproc(void);

void	closeioproc(Ioproc*);

void	iointerrupt(Ioproc*);

int	ioclose(Ioproc*, int);

int	iodial(Ioproc*, char*, char*, char*, int*);

int	ioopen(Ioproc*, char*, int);

long	ioread(Ioproc*, int, void*, long);

long	ioreadn(Ioproc*, int, void*, long);

long	iowrite(Ioproc*, int, void*, long);

int	iosleep(Ioproc*, long);

long	iocall(Ioproc*, long (*)(va_list*), ...);

void	ioret(Ioproc*, int);