function.bak

操作系统：用C++编写的时间片轮转法

#include "format.C"
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>

/* 函数声明 */
void interrupt newInt8(void);/* 具有按时间片调度功能的新的时钟中断函数 */
void initTcb(void);			/* 初始化线程控制块TCB */
void f1(void);				/* 输出50以内的平方 */
void f2(void);				/* 输出300以内的素数 */
void f3(void);					/* 输出30以内的 */
int create(char *name,codeptr code,int stackLen,int value);	/* 创建线程i，并返回i的值 */
void printTcbState(void);	/* 打印各线程的状态 */
int allThreadFinished(void);/* 若判断所有线程是否都结束，则返回1；否则返回0 */
void interrupt threadSwitch(void);	/* 执行线程间切换 */
struct buffer * initBuf(void);	/* 初始化消息缓冲队列 */
void block(struct TCB **p);	/* 阻塞当前线程 */
void wakeupFirst(struct TCB **p);/* 唤醒组塞的线程 */
void p(semaphore *sem);		/* 对信号量的P操作 */
void v(semaphore *sem);		/* 对信号量的V操作 */
struct buffer *getBuf(void);/* 从空闲消息缓冲队列头上取下一缓冲区，返回指向该缓冲区的指针 */
void putBuf(struct buffer *pt);	/* 将消息缓冲队列 pt 插入到空闲消息缓冲队列 freeBuf 中 */
void insert(struct buffer **mq,struct buffer *buff); /* 将buff所指的缓冲区插到*mq所指的缓冲区队列末尾 */
void send(char *receiver,char *a,int size);	/* 将地址a开始的size个字节发送给外部标识符为receiver的线程 */
void receive(char *sender,char *a);
void sendFun(void);
void receiveFun(void);
void initView(void);

/* 初始化线程控制块TCB */
void initTcb(void)
{
	int i;

	for(i = 0; i < NTCB; ++i)
	{
		tcb[i].state = BLANK;
		tcb[i].mq = NULL;
		tcb[i].mutex.value = 1;
		tcb[i].mutex.wq = NULL;
		tcb[i].sm.value = 0;
		tcb[i].sm.wq = NULL;
	}

	return ;
}/* initTcb */

/* 撤销tcb[id]对应的线程 */
void destroy(int id)
{
	if(tcb[id].state == RUNNING)
	{
		disable();	/* 关闭中断 */

		tcb[id].state = FINISHED;
		free(tcb[id].stack);

		enable();	/* 打开中断 */		
	}

	return ;
} /* destroy */

void over(void)
{
	destroy(current);
	threadSwitch();

	return ;
} /* over */

/* 创建线程i，并返回i的值 */
int create(char *name,codeptr code,int stackLen,int value)
{
	int i;
	char *p;
	struct int_regs *pt;

	/* 申请空闲TCB */
	for(i = 1; i < NTCB; ++i)
		if(tcb[i].state == BLANK || tcb[i].state == FINISHED)
		{/* 已得到空闲TCB */
			/* 初始化tcb[i] */
			tcb[i].value = value;
			strcpy(tcb[i].name,name);			
			tcb[i].stack = p = (unsigned char *)malloc(stackLen);

			/* 地址定位到tcb起始地址 */
			p += stackLen;
			pt = (struct int_regs *)p;
			pt--;
			tcb[i].ss = FP_SEG(pt);
			tcb[i].sp = FP_OFF(pt);
			tcb[i].state = READY;

			/* 初始化寄存器 */
			pt->ds = _DS;
			pt->es = _ES;
			pt->ip = FP_OFF(code);
			pt->cs = FP_SEG(code);
			pt->flags = 0x200;
			pt->off = FP_OFF(over);
			pt->seg = FP_SEG(over);			

			return i;
		}

	return -1;
} /* create */

/* 打印各线程的状态 */
void printTcbState(void)
{
	int i;

	putchar('\n');
	for(i = 0; i < NTCB; ++i)
		if(tcb[i].state != BLANK)
		{
			switch(tcb[i].state)
			{
				case FINISHED: printf("Thread%d# is FINISHED !\n",i); break;
				case RUNNING: printf("Thread%d# is RUNNING !\n",i); break;
				case READY: printf("Thread%d# is READY !\n",i); break;
				case BLOCKED: printf("Thread%d# is BLOCKED !\n",i); break;
				default: ; /* 在这里该语句可无 */
			}
		}
	putchar('\n');

	return ;
} /* TcbState */

/* 返回已就绪的线程号i */
int findReadyThread(void)
{
	int next,nextv;

	for(next = current + 1; next != current; ++next)
	{
		next %= NTCB;
		if(tcb[next].state == READY)
			break;
	}
	/* 若只有main线程，则把0赋值给current */
	if(next == current)
		return 0;
	/* 获得高优先权的线程 */
	for(nextv = next+1; nextv != current; ++nextv)
	{
		nextv %= NTCB; 
		if(tcb[nextv].state == READY)
			if(tcb[nextv].value > tcb[next].value)
				next = nextv;
	}

	return next;
} /* findReadyThread */

void subValue(void)
{
	tcb[currnet].value -= 2;
} /* subValue */

/* 具有按时间片调度功能的新的时钟中断函数 */
void interrupt newInt8(void)
{
	(*oldInt8)();
	++timecount;
	if(timecount == TB)
	{
		printf("\n");
		if(!dosBusy())
		{
			disable();

			subValue();
			tcb[current].ss = _SS;
			tcb[current].sp = _SP;
			if(tcb[current].state == RUNNING)
				tcb[current].state = READY;
			nextc = findReadyThread();
			_SS = tcb[nextc].ss;
			_SP = tcb[nextc].sp;
			tcb[nextc].state = RUNNING;
			current = nextc;
			timecount = 0;

			enable();
		}
	}

	return ;
} /* newInt8 */

/* 执行线程间切换 */
void interrupt threadSwitch(void)
{	
	nextc = findReadyThread();

	disable();	/* 关闭中断 */

	/* 保存现行堆栈的段址和栈顶供下次切换时用 */
	tcb[current].ss = _SS;
	tcb[current].sp = _SP;
	if(tcb[current].state == RUNNING)
		tcb[current].state = READY;

	/* 切换堆栈 */
	_SS = tcb[nextc].ss;
	_SP = tcb[nextc].sp;
	tcb[nextc].state = RUNNING;
	current = nextc;	
	
	enable();	/* 打开中断 */

	return ;
} /* threadSwitch */

/* 若判断所有线程是否都结束，则返回1；否则返回0 */
int allThreadFinished(void)
{
	int i;

	for(i = 1; i < NTCB; ++i)
		if(tcb[i].state != FINISHED && tcb[i].state != BLANK)
			return 0;

	return 1;
}/* allThreadFinished */

/* 阻塞当前线程 */
void block(struct TCB **p)
{
	struct TCB *p1;

	tcb[current].state = BLOCKED;
	if((*p) == NULL)
		*p = &tcb[current];
	else {
		p1 = *p;
		while(p1->next != NULL)
			p1 = p1->next;
		p1->next = &tcb[current];
	}
	tcb[current].next = NULL;
	threadSwitch();

	return ;
} /* block */

/* 唤醒组塞的线程 */
void wakeupFirst(struct TCB **p)
{
	struct TCB *p1;

	if((*p) == NULL)
		return ; /* 没有阻塞的线程 */
	/* 在阻塞队列中查找阻塞线程 */
	p1 = (*p);
	(*p) = (*p)->next;
	p1->state = READY;
	p1->next = NULL;

	return ;
} /* wakeupFirst */

/* 对信号量的P操作 */
void p(semaphore *sem)
{
	struct TCB **qp;

	disable();

	sem->value = sem->value - 1;
	if(sem->value < 0)
	{
		qp = &(sem->wq);
		block(qp);
	}

	enable();

	return ;
} /* p */

/* 对信号量的V操作 */
void v(semaphore *sem)
{
	struct TCB **qp;

	disable();

	qp = &(sem->wq);
	sem->value = sem->value + 1;
	if(sem->value <= 0)
		wakeupFirst(qp);

	enable();

	return ;
} /* v */

/* 初始化消息缓冲队列 */
struct buffer * initBuf(void)
{
	struct buffer *p,*pt,*pt1;
	int i;

	pt1 = pt = (struct buffer *)malloc(sizeof(struct buffer)); /* 首节点 */
	pt->sender = -1;
	pt->size = 0;
	strcpy(pt->text,"");
	pt->next = NULL;
	for(i = 0; i < NBUF-1; ++i)
	{
		p = (struct buffer *)malloc(sizeof(struct buffer));
		p->sender = -1;
		p->size = 0;
		strcpy(p->text,"");
		p->next = NULL;
		pt1->next = p;
		pt1 = p;
	}

	return pt;
} /* initBuf */

/* 从空闲消息缓冲队列头上取下一缓冲区，返回指向该缓冲区的指针 */
struct buffer *getBuf(void)
{
	struct buffer *buff;
	buff = freeBuf;
	freeBuf = freeBuf->next;

	return(buff);
} /* getBuf */

/* 将消息缓冲队列 pt 插入到空闲消息缓冲队列 freeBuf 中 */
void putBuf(struct buffer *pt)
{
	struct buffer *p = freeBuf;

	while(p->next != NULL)
		p = p->next;
	p->next = pt;
	pt->next = NULL;

	return ;
} /* putBuf */

/* 将buff所指的缓冲区插到*mq所指的缓冲区队列末尾 */
void insert(struct buffer **mq,struct buffer *buff)
{
	struct buffer *temp;

	if(buff == NULL) return ;
	buff->next = NULL;
	if(*mq == NULL)
		*mq = buff;
	else {
		temp = *mq;
		while(temp->next != NULL)
			temp = temp->next;
		temp->next = buff;
	}

	return ;
} /* insert */

/* 将地址a开始的size个字节发送给外部标识符为receiver的线程 */
void send(char *receiver,char *a,int size)
{
	struct buffer *buff;
	int i, id = -1;

	disable();

	for(i = 0; i < NTCB; ++i)
		if(strcmp(receiver,tcb[i].name) == 0)
		{
			id = i; break;
		}
	if(id == -1)
	{	/* 没找到tcb[i].name与标识符为receiver相匹配 */
		printf("Error:Receiver not exist!\n");
		enable();
		return ;
	}

	p(&sfb);
	p(&mutexfb);
	buff = getBuf();
	v(&mutexfb);

	buff->sender = current;
	buff->size = size;
	buff->next = NULL;
	for(i = 0; i < buff->size; i++,a++)
		buff->text[i] = *a;

	p(&tcb[id].mutex);
	insert(&(tcb[id].mq),buff);
	v(&tcb[id].mutex);
	v(&tcb[id].sm);

	enable();

	return ;
} /* send */

/**/
void receive(char *sender,char *a)
{
	struct buffer *buff;
	int i;

	disable();

	for(i = 0; i < NTCB; ++i)
		if(strcmp(sender,tcb[i].name) == 0)
			break;
	if(i == NTCB)
	{
		printf("Error:Sender not exist!\n");
		enable();
		return ;
	}

	p(&tcb[current].sm);
	p(&tcb[current].mutex);
	buff = tcb[current].mq;
	tcb[current].mq = tcb[current].mq->next;
	for(i = 0; i < buff->size; i++,a++)
		b[i] = buff->text[i];
	b[i] = '\0';
	a = b;
	v(&tcb[current].mutex);
	buff->sender = -1;
	buff->size = 0;
	strcpy(buff->text,"");
	buff->next = NULL;
	p(&mutexfb);
	putBuf(buff);
	v(&mutexfb);
	v(&sfb);

	enable();

	return ;
} /* receive */

void sendFun(void)
{
	int i,j;
	int size;

	size = strlen(words);
	send("receiver",words,size);
	for(i = 0; i < 10000; ++i)
		for(j = 0; j < 10000; ++j)
			;

	return ;
} /* sendFun */

void receiveFun(void)
{
	char *a;
	int i,j;

	receive("sender",a);
	printf("%50s\n",b);
	for(i = 0; i < 10000; ++i)
		for(j = 0; j < 10000; ++j)
			;

	return ;
} /* receiveFun */

/* 输出50以内的平方 */
void f1(void)
{
	int i,j,k,g;

	for(i = 1; i < 50; ++i) {
		printf("%d\n",i*i);
		/* 延时 */
		for(j = 0; j < 1000; ++j)
			for(k = 0; k < 1000; ++k)
				for(g = 0; g < 100; ++g)
					;
	}

	return ;
} /* f1 */

/* 输出300以内的素数 */
void f2(void)
{
	int i,j,k,g,sq;
	int flag;

	for(i = 2; i <= 300; i += 2) {
		flag = 0;
		sq = sqrt(i) + 1;
		for(j = 2; j < sq; ++j)
			if(i % j == 0)
			{
				if(i != 2) flag = 1;
				break;
			}
		if(flag == 0) printf("%10d\n",i);
		/* 延时 */
		for(k = 0; k < 10000; ++k)
			for(g = 0; g < 1000; ++g)
				;
	}
	putchar('\n');

	return ;
} /* f2 */

/* 输出30以内的 */
void f3(void)
{
	long f,f1,f2;
	int i,j,g,k;

	f1 = 1; f2 = 0;
	for(i = 1; i < 31; ++i)
	{
		f = f1 + f2;
		f1 = f2;
		f2 = f;
		printf("%25ld\n",f);
		/* 延时 */
		for(j = 0; j < 1000; ++j)
			for(k = 0; k < 1000; ++k)
				for(g = 0; g < 1000; ++g)
					;
	}

	return ;
} /* f3 */

void initView(void)
{
	int id;
	int value;

	disable();

	printf("Thread 0# is main thread.\n");
	printf("Thread 1# is to calculate the number square from 1 to 50.\n");
	printf("Thread 2# is to find prime number from 1 to 100.\n");
	printf("Thread 3# is to calculate the fib sequence number.\n");
	printf("Thread 4# is to send message.\n");
	printf("Thread 5# is to receive message.\n");
	printf("Select you want to create thread id(0 < id < 6):(enter id <= 0 is sover)\n");
	while(scanf("%d",&id) && id > 0)
	{
		switch(id)
		{
		case 1:
			printf("Enter the %d# thread's value: ",id);
			scanf("%d", &value);

			create("f1",(codeptr)f1,1024,value);
			printf("%d# thread is create.\n", id);
			break;
		case 2:
			printf("Enter the %d# thread's value: ",id);
			scanf("%d", &value);

			create("f2",(codeptr)f2,1024,value);
			printf("%d# thread is create.\n", id);
			break;
		case 3:
			printf("Enter the %d# thread's value: ",id);
			scanf("%d", &value);

			create("f3",(codeptr)f3,1024,value);
			printf("%d# thread is create.\n", id);
			break;
		case 4:
			printf("Enter the %d# thread's value: ",id);
			scanf("%d", &value);
			printf("Enter your message: ");
			getchar();
			gets(words);

			create("sender",(codeptr)sendFun,1024,value);
			printf("%d# thread is create.\n", id);
			break;
		case 5:
			printf("Enter the %d# thread's value: ",id);
			scanf("%d", &value);

			create("receiver",(codeptr)receiveFun,1024,value);
			printf("%d# thread is create.\n", id);
			break;
		default: ;
		}
	}

	enable();

	return ;
} /* initView */