基于DOS的多任务系统的实现(时间片)-操作系统

unsigned char *stack; /*线程堆栈起始地址*/
unsigned ss; /*堆栈段址*/
unsigned sp; /*堆栈指针*/
char state; /*线程状态*/
char name[15]; /*线程外部标识符*/
struct TCB *next;
enable();
}
void interrupt my_swtch(void)
{
disable();/*开中断*/
/*保护正在执行的线程current的现场，暂停它的执行*/
tcb[current].ss=_SS;
tcb[current].sp=_SP;
if(tcb[current].state==RUNNING)
}
void proceducer()
{
int i, j, k;
for(i = 1; i <=13;i++){
wait(&empty);
wait(&mutex);
buffer[in] = i*i;
printf("%s puts a number of %d in the buffer \n",tcb[current].name, buffer[in]);
struct SREGS segregs;
regs.h.ah = GET_INDOS;
intdosx(&regs,&regs,&segregs);
indos_ptr = MK_FP(segregs.es,regs.x.bx);
if(_osmajor<3) crit_err_ptr = indos_ptr+1;
typedef int (far *codeptr)(void); /*定义了一个函数指针类型*/
int buffer[NBUF] = {-1,-1,-1,-1,-1,-1}; /*生产者消费者中的缓冲区*/
int in = 0;
int out = 0;
typedef struct{
int value;
my_swtch();
}
void tcb_state()
{
int i;
printf("These are the information of all threads: \n");
for(i=0;i<NTCB-1;i++)
{
printf("the key word of the thread is : %d\n the name of thread is : %s\n the state of the thread is ",i,tcb[i].name);
switch(tcb[i].state)
{
case (1): printf("Running \n");break;
case (2): printf("Ready \n");break;
case (3): printf("Blocked\n");break;
case (0): printf("Finished\n");break;
tcb[current].state=READY;
/*找到新的就绪线程i*/
current=Seeknext();
tcb[current].state=RUNNING;
/*切换堆栈，恢复线程i的现场，把CPU分派给它*/
_SS=tcb[current].ss;
_SP=tcb[current].sp;
if(timecount >= TC)
if(!DosBusy())
{
/*调用my_swtch进行重新调度*/
my_swtch();
}
}
void Destroy(int i)
{
if(tcb[i].state==RUNNING)
{
disable();
crit_err_ptr = MK_FP(segregs.ds,regs.x.si);
}
}
int DosBusy(void)
{
if(indos_ptr && crit_err_ptr)
return (*indos_ptr || *crit_err_ptr);
struct TCB *wq;
}semaphore;
semaphore mutex={1,NULL},empty={NBUF,NULL},full={0,NULL},Mutex2={1,NULL}; /*生产者消费者中的信号量*/
void InitDos(void)
{
union REGS regs;
#define NTCB 5 /*定义最大空闲TCB个数*/
#define TC 2 /*定义时间片长度*/
#define NBUF 6 /*定义缓冲区大小*/
#define GET_INDOS 0x34
#define GET_CRIT_ERR 0x5d06
struct TCB{
block(sem);
}
enable();
}
void signal(semaphore *sem)
{
disable();
sem->value = sem->value + 1;
if(sem->value <= 0)
wakeup(sem);
enable();
enable();
}
void wakeup(semaphore *sem)
{
struct TCB *p;
disable();
p = sem->wq;
if(p != NULL){
p->state = READY;
sem->wq = sem->wq->next;
tcb[i].sp = FP_OFF(temp);
return i;
}
void block(semaphore *sem)
{
struct TCB *p;
disable();
tcb[current].state = BLOCKED;
p = sem->wq;
if(p == NULL){
{
int i,ks;
i=current+1;
ks=0;
disable();
while(ks<NTCB)
{
if(tcb[i].state==READY)
{
return i;
}
i++;
ks++;
i=i%NTCB;
}
printf("Seeknext tcb is error!!\n");
i++;
if(i == NTCB) return -1; /*没有空闲TCB块可用*/
strcpy(tcb[i].name, name);
tcb[i].state = READY;
tcb[i].stack = (unsigned char*)malloc(stacklen); /*为新线程分配私有堆栈空间*/
tcb[i].stack = tcb[i].stack + stacklen;
/*初始化新线程的私有堆栈*/
temp = (struct int_regs *)tcb[i].stack-1;
temp->ds = _DS;
temp->es = _ES;
temp->flags = 0x200;
else if(_osmajor==3 && _osminor==0) crit_err_ptr = indos_ptr-1;
else{
regs.x.ax = GET_CRIT_ERR;
intdosx(&regs,&regs,&segregs);
#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#include<dos.h>
/*定义TCB状态 */
#define FINISHED 0
#define RUNNING 1
#define READY 2
#define BLOCKED 3
}tcb[NTCB];
/*初始化堆栈时使用*/
struct int_regs{
unsigned bp, di, si, ds, es, dx, cx, bx, ax, ip, cs, flags, off, seg;
};
char fpub[3];
int current= -1; /*定义一个当前TCB下标的全局变量*/
tcb[i].state=FINISHED;
free(tcb[i].stack);
enable();
}
return;
}
void over(void)
{
Destroy(current);
printf("%s is finished!\n", tcb[current].name);