linux进程调度模拟 linux进程调度详解_程序开发

linux进程调度模拟 linux进程调度详解

创始人

2024-06-07 03:31:13

0次

/*模拟实现LINUX进程调度的静态优先级算法和时间片轮转算法引入LINUX调度
*/
#include
#include
#include
#include
#include
#define RUN 1
#define SLEEP 0
#define READY 2
#define DEG_SCHEDULE
#define NUM 6
struct OSPCB
{
int PcbName ; /*进程名字*/
int ReqCount;   /*进程执行计数*/
int RunTime;/*进程执行时间数*/
int Prority;/*进程优先级*/
int PcbStatus; /*进程状态*/
int PcbTime;/*进程时间片*/
struct OSPCB* prev;
struct OSPCB *next;
};
struct ProcessQueue /*模拟CPU调度队列*/
{
struct OSPCB *PointerHead; /*指向进程链表头*/
int PcbNumber;/*CPU每次调度计数器*/
};
//static struct CriticalResource
//{
// int flag;
// char BufferVoice[2000];
//}
static int flag;
void *Function(int *arg);
void InitPcb(struct OSPCB *pcb);
int Schedule(struct ProcessQueue *queue);
void InheritSchedule(struct OSPCB *pcb);
int main(void)
{
int i,ret;
struct OSPCB *pNewPcb,*pNew;
struct ProcessQueue *pNewQueue;
int a[4][4] = {{1,1,0,1},{2,2,0,2},{3,3,0,3},{4,4,0,4}};
pNewQueue = (struct ProcessQueue *)malloc(sizeof(struct ProcessQueue));
pNewQueue->PointerHead = NULL;
pNewQueue->PcbNumber = 0;
for(i = 0; i < 4;i++) /*进程初始化*/
{
pNewPcb = (struct OSPCB *)malloc(sizeof(struct OSPCB));
pNewPcb->PcbName   = a[i][0];
pNewPcb->ReqCount = a[i][1];
pNewPcb->RunTime   = a[i][2];
pNewPcb->Prority   = a[i][3];
pNewPcb->PcbStatus = READY;
pNewPcb->PcbTime   = 3;
InitPcb(pNewPcb);
if(pNewQueue->PointerHead == NULL)
{
pNewQueue->PointerHead = pNewPcb;
}else{
pNew->next = pNewPcb;
pNewPcb->prev = pNew;
}
pNew = pNewPcb;
pNewQueue->PcbNumber++;
}
#if 0
for(p = pNewQueue->PointerHead; p != NULL; p = p->next)
{
printf("process name = %d\n",p->PcbName);
}
#endif
Schedule(pNewQueue);/*进入进程调度*/
return 0;
}
void InitPcb(struct OSPCB *pcb)
{
pcb->prev = NULL;
pcb->next = NULL;
}
int Schedule(struct ProcessQueue *queue) /*进程调度*/
{
struct OSPCB *pcb,*CurrRun;
int value,SechNumber = 8;
pthread_t pthread_id[NUM];
int i = 0;
// printf("%s\n",__FUNCTION__);
for(pcb = queue->PointerHead;pcb !=NULL;pcb = pcb->next)
{
if(pcb->PcbTime == 0)
{
pcb->Prority +=4;
}
pcb->PcbTime = 3;
}
while(queue->PointerHead != NULL)
{
for(pcb = queue->PointerHead;pcb !=NULL;pcb = pcb->next)
{
if(pcb == queue->PointerHead)
{
CurrRun = pcb;
}else{
if(CurrRun->Prority < pcb->Prority)
CurrRun = pcb;
}
CurrRun->PcbStatus = RUN;
}
SechNumber--;
CurrRun->ReqCount--;
CurrRun->PcbTime--;
if(i != (CurrRun->PcbName))
{
i = CurrRun->PcbName;
pthread_create(&pthread_id[i],NULL,(void*)Function,&(CurrRun->PcbName));
}
#ifdef DEG_SCHEDULE
printf("present process = %d CurrRun->ReqCount = %d\n",CurrRun->PcbName,CurrRun->ReqCount);
#endif
if(CurrRun->PcbTime == 0)
{
CurrRun->Prority -=4; /*进程惩罚性降优先级处理*/
}
if(CurrRun->ReqCount == 0)
{
if(CurrRun == queue->PointerHead)
{
queue->PointerHead = CurrRun->next;
}else if (CurrRun->next != NULL){
CurrRun->prev->next = CurrRun->next;
CurrRun->next->prev = CurrRun->prev;
}else{
CurrRun->prev->next = NULL;
}
//   printf("Run process name = %d Reqcount = %d Sechedule count = %d\n",CurrRun->PcbName,CurrRun->ReqCount,SechNumber);
}
if(SechNumber == 0)/*时间片用完重新调度*/
{
Schedule(queue);
}
}
return 0;
}
void SleepProcess(void)
{
}
void DeleteProcess(void)
{
// return 0;
}
void *Function(int *arg) /*进程执行函数*/
{
int i,count = 0;
int PthreadName;
struct OSPCB *pNew;
pNew = (struct OSPCB *)arg;
PthreadName = *(int *)arg;
#ifdef DEG_SCHEDULE
printf("Enter the function process %d\n", PthreadName);
#endif
while(1)
{
if(flag == 0) /*访问临界区资源*/
{
flag = 1;
#ifdef DEG_SCHEDULE
printf("get lcok in process %d\n", PthreadName);
#endif
for(i = 0; i < 10000; i++)
{
pNew->PcbStatus = SLEEP;
sleep(1);
}
flag = 0;/*释放临界区资源*/
break;
}else{ /*自旋直到得到可访问的临界区资源*/
count++;
if(count == 5000)
{
#ifdef DEG_SCHEDULE
printf("flag = %d can not get lock in process name %d\n",flag,PthreadName);
#endif
}
}
}
#ifdef DEG_SCHEDULE
printf("flag = %d out process %d\n", flag,PthreadName);
#endif
}

【编辑推荐】

Linux应用：在Fedora 下安装opera浏览器
linux死机了怎么办处理办法详细解析
linux块设备，字符设备

上一篇：Linux/Unix下常用数学计算

下一篇：Windows Embedded Standard 2011工具包介绍

linux进程调度模拟 linux进程调度详解

相关内容

热门资讯