linux进程调度模拟

 /*模拟实现LINUX进程调度的静态优先级算法和时间片轮转算法引入LINUX调度
    */
    #include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <sys/stat.h>
    #include <sys/types.h>
    #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){
 &n

bsp;  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
    } 本文作者:未知