精华内容
下载资源
问答
  • 作业调度

    千次阅读 2017-06-20 22:15:15
    实验一 作业调度(先来先到)一、 实验目的 用高级语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。二、 实验内容 1. 写并调试一个单道处理系统的作业等待模拟程序。 2. 作业等待...

    一、 实验目的
    用高级语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。

    二、 实验内容
    1. 写并调试一个单道处理系统的作业等待模拟程序。
    2. 作业等待算法:分别采用先来先服务(FCFS)、响应比高者优先(HRN)的调度算法。
    3. 由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU时限等因素。
    4. 每个作业由一个作业控制块JCB表示,JCB可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。
    5. 对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。

    三、实现思路
    通过自己编写一个文件并键入作业信息,程序读取文件信息计算长度,之后连接好链表并将文件信息(包括文件名,运行时间,到达时间)存入存储链表;然后在循环中调用检查函数每次显示正在运行的进程和等待进程,同时将已到达的进程放入另一个可运行链表;同时对可运行链表运行执行进程,将运行完的进程放入结构数组存储,接着调用排序函数,最后链表指向下一项,该循环运行直到到达链表结尾;最后,调用显示函数显示要求的信息。高响应比

    通过自己编写一个文件并键入作业信息,程序读取文件信息计算长度,之后连接好链表并将文件信息(包括文件名,运行时间,到达时间,优先级)存入存储链表;这了的优先级在两个作业同时到达时起作用。然后在循环中调用检查函数每次显示正在运行的进程和等待进程,将运行完的进程放入结构数组存储,接着调用排序函数,最后链表指向下一项,该循环运行直到到达链表结尾;最后,调用显示函数显示要求的信息。 先来先服务

    四、主要的数据结构
    结构链表,txt文件。
    struct pcb /* 定义进程控制块PCB */
    {
    char name[namelen];
    char state; // 状态
    double super; // 优先级
    int ntime; // 需要运行时间
    int rtime; // 实际运行时间
    int betime;// 开始时间
    int fintime;//结束时间
    int artime; //到达时间
    int in; //是否在可运行链表中
    struct pcb * link; // 链指针
    }; // 高响应比

    struct JCB /* 定义进程控制块JCB */
    {
    char name[namelen];
    char state; // 状态
    int ntime; // 需要运行时间
    int rtime; // 实际运行时间
    int betime;// 开始时间
    int fintime;//结束时间
    int artime; //到达时间
    struct JCB * link; // 链指针
    };// 先来先服务

    五、代码:
    先来先服务:

    // HRRN algorithm
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define namelen 10
    #define bufsize 20
    
    struct JCB   /* 定义进程控制块PCB */
    {
        char name[namelen];
        char state; // 状态
        int ntime; // 需要运行时间
        int rtime; // 实际运行时间
        int betime;// 开始时间
        int fintime;//结束时间
        int artime; //到达时间
        struct JCB * link; // 链指针
    };
    
    int link ( struct JCB * jcblist, int len)
    {
        int i;
        jcblist[len].link = NULL;
        for ( i = len; i > 0; i--)
            jcblist[i-1].link = &jcblist[i];
        return 1;
    }
    
    int check ( struct JCB * jcblist, int *curtime )
    {
        struct JCB * temp;
        while ( jcblist->link != NULL )
        {
            if ( jcblist->artime > *curtime ) // no arrived jobs
            {
                printf ("No arrived jobs.\n");
                return 0;
            }
            else
            {
                printf ( "The executing job:%s\n", jcblist->name);
                break;
            }
            jcblist = jcblist->link;
        }
        temp = jcblist+1;
        if ( temp->artime > *curtime )
        {
            printf ( "No jobs in waiting queue.\n");
            return 0;
        }
        else
        {
    
            printf ( "In waiting queue:\n");
            while ( temp->artime <= *curtime &&  temp->link != NULL )
            {
                disp( temp );
                temp = temp->link;
            }
        }
        return 1;
    }
    
    int sort ( struct JCB * jcblist ) // insertion sort
    {
        int i, j, pl = 0;
        for ( ; jcblist[pl].link != NULL && jcblist[pl].link->ntime != 0; pl++ )
            ; // the length of the current jcblist
        if ( pl == 0 || pl == 1)
        {
            printf ( "Nothing!\n");
            return 0;
        }
        struct JCB * temp = (struct JCB *)malloc( sizeof( struct JCB));
        for ( i = 1; i < pl && jcblist[i].ntime != 0; i++ ) // use insertion sort
        {
            j = i;
            strcpy(temp->name, jcblist[i].name),
                   temp->ntime = jcblist[i].ntime,temp->artime = jcblist[i].artime ;
            while ( j > 0 && temp->artime < jcblist[j-1].artime )
            {
                strcpy(jcblist[j].name, jcblist[j-1].name),
                       jcblist[j].ntime = jcblist[j-1].ntime,jcblist[j].artime = jcblist[j-1].artime ;
                j--;
            }
            strcpy(jcblist[j].name, temp->name),
                   jcblist[j].ntime = temp->ntime, jcblist[j].artime = temp->artime;
        }
        free ( temp );
        return 1;
    }
    
    int running ( struct JCB * p, struct JCB store[], int * arrlen, int * curtime )
    {
        printf ( "running...\n");
        if ( p->rtime == 0 )
            p->betime = *curtime;
        while ( p->rtime < p->ntime )
            p->rtime = p->rtime + 1, *curtime = *curtime + 1; // 运行时间
        if ( p->rtime == p->ntime ) // 运行时间等于需要时间
        {
            p->state = 'F', p->fintime = *curtime;
            strcpy(store[*arrlen].name, p->name), store[*arrlen].ntime = p->ntime;
            store[*arrlen].rtime = p->rtime, store[*arrlen].state = p->state;
            store[*arrlen].betime = p->betime;
            store[*arrlen].fintime = p->fintime, store[*arrlen].artime = p->artime;
            *arrlen = *arrlen+1;
            printf ( "Job:%s finished.\n\n\n", p->name);
        }
        return 1;
    }
    
    int disp ( struct JCB * pr)
    {
        printf(" qname \t state \t ndtime \n");
        printf(" |%s\t", pr->name);
        printf(" |%c\t", pr->state);
        printf(" |%d\t", pr->ntime);
        printf("\n");
        return 1;
    }
    
    int showresult ( struct JCB * store, int pcblen )
    {
        int arrlen;
        double tatime = 0.0, tatimewe = 0.0;
        for ( arrlen = 0; arrlen < pcblen; arrlen++ )
        {
            printf("\n qname \t state \t ndtime  btime \t endtime runtime artime 周转时间 带权周转时间\n");
            printf(" |%s\t", store[arrlen].name);
            printf(" |%c\t", store[arrlen].state);
            printf(" |%d\t", store[arrlen].ntime);
            printf(" |%d\t", store[arrlen].betime);
            printf(" |%d\t", store[arrlen].fintime);
            printf(" |%d\t", store[arrlen].rtime);
            printf(" |%d\t", store[arrlen].artime);
            printf(" |%d\t", store[arrlen].fintime - store[arrlen].artime);
            printf(" |%f\t", (double)( store[arrlen].fintime - store[arrlen].artime )/ store[arrlen].ntime);
            printf("\n");
            tatime += store[arrlen].fintime - store[arrlen].artime;
            tatimewe +=( store[arrlen].fintime - store[arrlen].artime )/ store[arrlen].ntime;
        }
        printf ( "\n平均周转时间 \t 带权周转时间\n");
        printf ( "|%f\t", tatime / pcblen );
        printf ( "|%f\t", tatimewe / pcblen);
    }
    
    int main ( void )
    {
    
        int i, j = 0, pcbnum = 0, curtime = 0, arrlen = 0;// job's number, current time store array's length counter
        int pcblen = 0, filechar;// arrlen: the length of store
        char * buffer = (char *)malloc( sizeof(char) * bufsize); // the buffer
        FILE * infor = fopen( "test.txt", "r");
        while ( (filechar = fgetc(infor)) != EOF)
            if ( filechar == '\n')
                pcblen++;
        pcblen += 1; // get the length of the file.
        struct JCB * jcblist = (struct JCB *)malloc( sizeof ( struct JCB)* pcblen);// allocate memory for the jobs
        struct JCB * store = (struct JCB *)malloc( sizeof ( struct JCB)* pcblen); // store list
        struct JCB * location1 = (struct JCB *)malloc(sizeof ( struct JCB));
        location1 = jcblist;
        link ( jcblist, pcblen);// link the pcblist arrpcb
        rewind( infor );
        // file information assignment
        while ( fgets(buffer, bufsize, infor) != NULL )
        {
            for ( i = 0; buffer[i] != ' '; i++ ) // name assignment
                jcblist[pcbnum].name[i] = buffer[i];
            jcblist[pcbnum].name[i] = '\0';
            jcblist[pcbnum].ntime = atoi(buffer + i); // ntime assignment
            i++;
            for ( ; buffer[i] != ' '; i++ )
                ;
            jcblist[pcbnum].artime = atoi( buffer + i);
            jcblist[pcbnum].state = 'W', jcblist[pcbnum].rtime = 0;
            pcbnum++;
        }
        sort ( jcblist );
        while ( j < pcblen )
        {
            printf ( "Current time:%d\n", curtime);
            check ( jcblist + j, &curtime ); // the header of arrpcb
            running( jcblist+j, store, &arrlen, &curtime ); // also calculate the super
            j++;
        }
        printf("\n\n All jobs have finished.\n");
        showresult ( store, pcblen );
        fclose( infor );
        free ( location1 ), free( store );
        return 0;
    }
    

    高响应比:

    // HRRN algorithm
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define namelen 10
    #define bufsize 20
    
    struct pcb   /* 定义进程控制块PCB */
    {
        char name[namelen];
        char state; // 状态
        double super; // 优先级
        int ntime; // 需要运行时间
        int rtime; // 实际运行时间
        int betime;// 开始时间
        int fintime;//结束时间
        int artime; //到达时间
        int in;     //是否在可运行链表中
        struct pcb * link; // 链指针
    };
    
    int link ( struct pcb * pcblist, int len)
    {
        int i;
        pcblist[len].link = NULL;
        for ( i = len; i > 0; i--)
            pcblist[i-1].link = &pcblist[i];
        return 1;
    }
    
    int check ( struct pcb * pcblist, struct pcb * arrpcb, int *curtime, int * arrpcblen, int * j )
    {
        int plco = 0, i = *j;// i record the current loc
        while ( pcblist[plco].link != NULL ) // put the arrived jobs into arrpcb
        {
            if ( pcblist[plco].in == 0 && pcblist[plco].artime <= *curtime && pcblist[plco].link != NULL)
            {
                arrpcb[*arrpcblen].ntime = pcblist[plco].ntime, strcpy(arrpcb[*arrpcblen].name, pcblist[plco].name);
                arrpcb[*arrpcblen].state = 'W', *arrpcblen = *arrpcblen + 1;
                pcblist[plco].in = 1, arrpcb[*arrpcblen].artime = pcblist[plco].artime;
            }
            plco++;
        }
        if ( arrpcb[i].ntime == 0 )
        {
            printf ( "No arrive jobs!\n");
            return 0;
        }
        struct pcb * temppcb2 = arrpcb->link; // calculate the super
        while (temppcb2->link != NULL && temppcb2->ntime != 0)
        {
            temppcb2->super = ((double)*curtime - (double)(temppcb2->artime)) / ( ((double)*curtime - (double)(temppcb2->artime)) + temppcb2->ntime);// 完成一个任务后更新优先级;
            temppcb2 = temppcb2->link;
        }
        sort(arrpcb + i);
        printf ( "\n The execute job :\n");
        arrpcb[i].state = 'R';// change the running job's state
        disp( arrpcb+i );
        struct pcb * temppcb1; // show the waiting queue
        temppcb1 = arrpcb[i].link;
        if ( temppcb1->link != NULL && temppcb1->ntime != 0  ) // show the jobs in the waiting queue
            printf("\n The jobs in waiting queue:\n");
        while ( temppcb1->link != NULL && temppcb1->ntime != 0 )
        {
            disp ( temppcb1 );
            temppcb1 = temppcb1->link;
        }
        return 1;
    }
    
    int sort ( struct pcb * arrpcb ) // insertion sort
    {
        int i, j, pl = 0;
        for ( ; arrpcb[pl].link != NULL && arrpcb[pl].link->ntime != 0; pl++ )
            ; // the length of the current arrpcb
        if ( pl == 0 || pl == 1)
            return 0;
        //printf ( "The current of the list:%d\n", pl);
        struct pcb * temp = (struct pcb *)malloc( sizeof( struct pcb));
        for ( i = 1; i < pl && arrpcb[i].ntime != 0; i++ ) // use insertion sort
        {
            j = i;
            temp->super = arrpcb[i].super, strcpy(temp->name, arrpcb[i].name),
                  temp->ntime = arrpcb[i].ntime;
            while ( j > 0 && temp->super > arrpcb[j-1].super )
            {
                arrpcb[j].super = arrpcb[j-1].super, strcpy(arrpcb[j].name, arrpcb[j-1].name),
                          arrpcb[j].ntime = arrpcb[j-1].ntime;
                j--;
            }
            arrpcb[j].super = temp->super, strcpy(arrpcb[j].name, temp->name),
                      arrpcb[j].ntime = temp->ntime;
        }
    
        free ( temp );
        return 1;
    }
    
    int running ( struct pcb * p, struct pcb store[], int * arrlen, int * curtime )
    {
        if ( p->rtime == 0 )
            p->betime = *curtime;
        while ( p->rtime < p->ntime )
            p->rtime = p->rtime + 1, *curtime = *curtime + 1; // 运行时间
        if ( p->rtime == p->ntime ) // 运行时间等于需要时间
        {
            p->state = 'F', p->fintime = *curtime;
            strcpy(store[*arrlen].name, p->name), store[*arrlen].ntime = p->ntime;
            store[*arrlen].rtime = p->rtime, store[*arrlen].state = p->state;
            store[*arrlen].super = p->super, store[*arrlen].betime = p->betime;
            store[*arrlen].fintime = p->fintime, store[*arrlen].artime = p->artime;
            *arrlen = *arrlen+1;
            printf ( "Job:%s finished.\n", p->name);
        }
        return 1;
    }
    
    int disp ( struct pcb * pr)
    {
        printf(" qname \t state \t ndtime \n");
        printf(" |%s\t", pr->name);
        printf(" |%c\t", pr->state);
        printf(" |%d\t", pr->ntime);
        printf("\n");
        return 1;
    }
    
    int showresult ( struct pcb * store, int pcblen )
    {
        int arrlen;
        double tatime = 0.0, tatimewe = 0.0;
        for ( arrlen = 0; arrlen < pcblen; arrlen++ )
        {
            printf("\n qname \t state \t ndtime  btime \t endtime runtime artime 周转时间 带权周转时间\n");
            printf(" |%s\t", store[arrlen].name);
            printf(" |%c\t", store[arrlen].state);
            printf(" |%d\t", store[arrlen].ntime);
            printf(" |%d\t", store[arrlen].betime);
            printf(" |%d\t", store[arrlen].fintime);
            printf(" |%d\t", store[arrlen].rtime);
            printf(" |%d\t", store[arrlen].artime);
            printf(" |%d\t", store[arrlen].fintime - store[arrlen].artime);
            printf(" |%f\t", (double)( store[arrlen].fintime - store[arrlen].artime )/ store[arrlen].ntime);
            printf("\n");
            tatime += store[arrlen].fintime - store[arrlen].artime;
            tatimewe +=( store[arrlen].fintime - store[arrlen].artime )/ store[arrlen].ntime;
        }
        printf ( "\n平均周转时间 \t 带权周转时间\n");
        printf ( "|%f\t", tatime / pcblen );
        printf ( "|%f\t", tatimewe / pcblen);
    }
    
    int main ( void )
    {
    
        int i, j = 0, pcbnum = 0, curtime = 0, arrlen = 0;// job's number, current time store array's length counter
        int pcblen = 0, filechar, arrpcblen = 0;// arrlen: the length of store
        char * buffer = (char *)malloc( sizeof(char) * bufsize); // the buffer
        FILE * infor = fopen( "test.txt", "r");
        while ( (filechar = fgetc(infor)) != EOF)
            if ( filechar == '\n')
                pcblen++;
        pcblen += 1; // get the length of the file.
        struct pcb * pcblist = (struct pcb *)malloc( sizeof ( struct pcb)* pcblen);// allocate memory for the jobs
        struct pcb * store = (struct pcb *)malloc( sizeof ( struct pcb)* pcblen); // store list
        struct pcb * arrpcb = (struct pcb *)malloc( sizeof ( struct pcb)* pcblen); // arrived jobs
        struct pcb * location1 = (struct pcb *)malloc(sizeof ( struct pcb));
        struct pcb * location2 = (struct pcb *)malloc(sizeof ( struct pcb));
        memset( arrpcb, 0, sizeof(struct pcb) * pcblen );
        location1 = pcblist, location2 = pcblist;
        link ( pcblist, pcblen),  link ( arrpcb, pcblen);// link the pcblist arrpcb
        rewind( infor );
        // file information assignment
        while ( fgets(buffer, bufsize, infor) != NULL )
        {
            for ( i = 0; buffer[i] != ' '; i++ ) // name assignment
                pcblist[pcbnum].name[i] = buffer[i];
            pcblist[pcbnum].name[i] = '\0';
            pcblist[pcbnum].ntime = atoi(buffer + i); // ntime assignment
            i++;
            for ( ; buffer[i] != ' '; i++ )
                ;
            pcblist[pcbnum].artime = atoi( buffer + i);
            pcblist[pcbnum].state = 'W', pcblist[pcbnum].rtime = 0;
            pcblist[pcbnum].super = 1.0, pcblist[pcbnum].in = 0;
            pcbnum++;
        }
    
        while ( j < pcblen )
        {
            printf ( "\nCurrent time:%d", curtime);
            check ( pcblist, arrpcb, &curtime, &arrpcblen, &j ); // the header of arrpcb
            running( arrpcb + j, store, &arrlen, &curtime );// also calculate the super
            sort(arrpcb+j+1);
            j++;
            i = 0;
        }
        printf("\n\n All jobs have finished.\n");
        showresult ( store, pcblen );
        free ( location1 ), free( location2 ), free( store );
        return 0;
    }
    

    对比:
    高响应比:结构体较为复杂,代码实现较为复杂,思路也相对复杂一些,每次运行完需要更新每个作业的优先级别,运行时间相对会多一些。(例子中数据比较少,因此区别不大)
    同时,很明显,平均周转时间和带权周转时间相对小。
    先到先服务:结构体相对简单,代码简单些,只需要一次排序(代码中对同一时间到达的作业按输入顺序执行)。运行时间较短。最后,平均周转时间和带权周转时间相对较大。
    总结:从运行结果可以看出,对于不多的输入数据,高响应比和先到先服务对作业的调度时间相差不大;但对于较多的输入数据,高响应比会比先到先服务的调度时间少。同时,高响应比作业调度方面因为是动态优先级会比先到先得更加合理。

    展开全文
  • 作业调度问题作业调度问题作业调度问题作业调度问题作业调度问题作业调度问题
  • 编写并调试一个综合使用作业调度和进程调度模拟的作业调度程序,采用“简单时间片轮转法”调度算法为多道批处理系统设计一个作业调度程序。 (1)、编写并调试一个多道批处理系统设计一个作业调度程序 (2)、作业...
  • 操作系统os进程调度,作业调度以及请求分页系统的实现,其中进程调度涉及FCFS算法,时间片轮转法以及多级反馈队列实现。作业调度涉及FCFS以及短作业优先等。有源代码以及文档解释
  • 进程作业调度

    2018-03-04 00:39:49
    课程设计题目:进程/作业调度 实现要求: 1. 建立作业的数据结构描述 2. 使用两种方式产生作业/进程: (a)自动产生 (b)手工输入 3. 在屏幕上显示每个作业/进程的执行情况。 4. 时间的流逝可用下面几种方法模拟:(a)按...
  • 作业调度算法 1.先来先服务 2.最短优先 3.高响应比优先 4.优先级 作业调度和进程调度的区别 作业调度又称为高级调度,频度较低。其主要工作是将位于外存后备队列中的某个(或某几个)作业调入内存,排在就绪队列上。...

    进程调度算法
    1.先来先服务
    2.最短优先
    3.剩余最短优先
    4.高响应比
    5.时间片轮转
    6.多级反馈队列
    7.优先级

    作业调度算法
    1.先来先服务
    2.最短优先
    3.高响应比优先
    4.优先级

    作业调度和进程调度的区别
    作业调度又称为高级调度,频度较低。其主要工作是将位于外存后备队列中的某个(或某几个)作业调入内存,排在就绪队列上。注意了,这个时候仅仅是将作业调入内存,并为作业创建进程、分配资源,此时进程处于就绪态,并没有执行。

    进程调度
    其主要任务是从就绪队列中选取一个(或几个)进程,并分配处理机的过程,这时候才可以理解为“执行”。

    展开全文
  • Flink作业调度

    千次阅读 2020-01-09 11:29:13
    Flink作业调度 1.如何进行作业调度 实际上作业调度可以看作是对资源和任务进行匹配的过程。在Flink中,资源是通过slot来表示的,每个slot可以用来执行不同的Task。调度的主要目的就是为了给Task找到匹配的slot。 该...

    Flink作业调度

    1.如何进行作业调度

    实际上作业调度可以看作是对资源和任务进行匹配的过程。在Flink中,资源是通过slot来表示的,每个slot可以用来执行不同的Task。调度的主要目的就是为了给Task找到匹配的slot。
    在这里插入图片描述该图表示的就是flink的作业调度过程,从图中我们可以清晰的看出来一个作业的整个提交调度过程。
    master-slave:
    AM(AppMaster):master,负责管理整个集群中的资源和作业。
    TaskExecutor:slave,负责提供具体的资源并实际执行作业。
    Master部分包含3个组件:Dispatcher、ResourceManager和JobManager
    (1)Dispatcher负责接收用户提交作业,并且负责为这个新提交的作业拉起一个新的JobManager组件。
    (2)ResourceManager负责资源管理。
    (3)JobManager负责管理作业的执行,在一个Flink集群中可能有多个作业同时执行,每个作业都有自己的JobManager组件。
    作业调度的整个流程:
    1.用户提交作业,提交作业会首先启动一个Client进程负责作业的编译和提交。它首先将用户编写的代码编译为一个JobGraph。(还会进行一些检查或者优化工作,例如判断哪些Operator可以Chain到同一个Task中)然后将JobGraph提交到集群中执行,这个时候需要判断当前模式,
    (1)若类似Standalone Session模式,AM会预先启动,Client直接与Dispatcher建立连接并提交作业即可。
    (2)若是Per-Job模式,AM不会预先启动,Client首先向资源管理系统(如Yarn)申请资源来启动AM,再向Dispatcher提交作业。
    以上步骤对应图中的前3步。
    2.当作业提交到Dispatcher后,Dispatcer会首先启动一个JobManager组件。图中第4步。
    3.JobManager会向ResourceManager申请资源来启动作业中的具体任务。这个时候要看TaskExecutor是否启动。
    (1)若类似Standalone Session模式,则RM中已有TaskExecutor注册的资源,可以直接选择空闲的资源进程进行分配。
    (2)若是Per-Job模式,RM首先向外部资源管理系统申请启动TM。
    对应图中的5,6,7步。
    4.RM选择空闲的slot后,通知TM,然后TaskExecutor进行相应的记录后,会向JM进行注册。JM收到TaskExecutor注册的slot后,可以实际提交Task。对应图中的8,9,10步。
    5.TM收到JM提交的Task后,会启动一个新的线程,Task启动后,就可以进行预先指定的计算,Task之间可以Shuffle交换数据。

    下面解释一下上面提到的两种模式的区别:
    (1)Per-Job:独享Dispatcher和ResourceManager,按需要申请资源,适合执行时间较长的大作业。
    (2)Session:共享Dispatcher和ResourceManager,共享资源,适合规模小,执行时间短的作业。

    2.Flink中按什么顺序调度Task?

    Flink调度中总共有两种调度顺序,一种是Eager调度,一种是LAZY_From_Source调度。
    (1)Eager调度会在作业启动时申请资源将所有的Task调度起来,主要用来调度可能没有中止的流作业。(Task正常情况下不存在退出结束的行为)
    (2)LAZY_From_Source调度是从source开始,按拓扑排序来进行调度,会先调度没有上游任务的source任务。当这些任务完成时,它会将输出数据缓存到内存或者写入磁盘中。对于后续任务,它的前驱任务全部执行完成后,Flink就会将这些任务调度起来。
    在这里插入图片描述

    展开全文
  • 作业调度基本原理

    2018-06-24 15:45:37
    作业调度基本原理基本概念 : 工作原理 产品对比 作业示例
  • c语言编写和调试一个或多个作业调度的模拟程序,以加深对作业调度算法的理解。3. 由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否...
  • 1.在批处理系统中,因作业进入系统后先驻留在外存,故需要有作业调度。在分时系统中为做到及时响应,作业被直接送入内存,故不需作业调度。在实时系统中,通常也不需作业调度 2.作业调度算法 先来先服务和短作业...

    1. 在批处理系统中,因作业进入系统后先驻留在外存,故需要有作业调度。在分时系统中为做到及时响应,作业被直接送入内存,故不需作业调度。在实时系统中,通常也不需作业调度

    2. 作业调度算法

    先来先服务和短作业(进程)优先调度算法

    高优先权调度算法和高响应比优先调度算法

    先来先服务:

    优点:有利于长作业

    缺点:不利于短作业

    FCFS调度算法有利于CPU繁忙型的作业,而不利于I/O繁忙型的作业(进程)

    ➢ CPU繁忙型作业:如通常的科学计算。

    ➢ I/O繁忙型作业 :指CPU进行处理时,需频繁的请求I/O。

     

    3. SJF算法可以分别用于作业调度和进程调度。

    4. SJF的优点:

    (1)有效降低作业的平均等待时间,提高系统的吞吐量

    缺点:

    (1)对长作业非常不利,长作业的周转时间会明显地增长。可能使作业等待时间过长,出现饥饿现象。

    (2)采用SJF算法时,人机无法实现交互。

    (3)完全未考虑作业的紧迫程度。

    5. 高响应比优先调度算法既考虑了作业的等待时间,又考虑作业运行时间,既照顾了短作业,又不致使长作业的等待时间过长。

    优先权=(等待时间+要求服务时间)/要求服务时间

    Rp=响应时间/要求服务时间

     

    基于时间片的轮转:(1)时间片轮转法(2)多级反馈队列调度算法

    展开全文
  • 基于SSM的作业调度平台 支持时间调度、作业依赖触发、手工执行三种调度方式。 时间调度:底层基于quartz实现,支持cron命令,实现灵活的时间调度方式。 作业依赖触发:一个子作业可以依赖多个父作业,一个父作业...
  • 常见作业调度算法

    千次阅读 2020-08-28 22:21:53
    作业调度的算法:  1:先来先服务算法(FSFS)最简单的调度算法,既可用于作业调度也可用于进程调度,系统按照作业到达的先后顺序进行调度,或者是优先考虑在系统中等待时间最长的作业  2:短作业优先调度算法...
  • 作业调度实验

    2011-12-11 21:20:55
    模拟作业调度的实现,了解作业调度在操作系统中的作用。可采用先来先服务算法和运行时间最短者优先算法模拟设计作业调度程序。帮助学生加深了解作业调度的工作原理。
  • 进程调度 时间片轮转与优先级 作业调度 高响应比 短作业 先到先服务 进程调度 时间片轮转与优先级 作业调度 高响应比 短作业 先到先服务
  • 作业调度(高级调度):其主要任务是按一定的原则从外存上处于后备状态的作业中挑选一个(或多个)作业,给他们分配内存、输入/输出设备等标有资源,并建立相应的进程,作业调度一般只存在多道批处理系统中。...
  • 作业调度代码

    2013-11-12 21:58:54
    1、 对作业调度的相关内容作进一步的理解。 2、 明白作业调度的主要任务。 3、 通过编程掌握作业调度的主要算法。 二、 实验内容及要求 1、对于给定的一组作业, 给出其到达时间和运行时间,例如下表所示:, 作业名 A...
  • 进程调度与作业调度

    2019-10-04 04:02:48
    作业调度按一定的算法从磁盘上的“输入井”中选择资源能得到满足的作业装入内存,使作业有机会去占用处理器执行。 但是,一个作业能否占用处理器,什么时间能够占用处理器,必须由进程调度来决定。所以,作业调度...
  • 作业调度算法

    2021-04-05 16:48:14
    适用于作业调度 从后备作业队列中选择–个或多个最先进入的作业,将它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。 适用于进程调度 从就绪进程队列中选择一个最先进入的进程,为之分配处理机,使之...
  • 作业调度和进程调度的辨析

    千次阅读 多人点赞 2020-10-11 22:46:36
    但是在实际做题的时候,往往一不小心就把概念搞错,不容易区分“作业调度”和“进程调度”的区别。下面我主要针对这两个概念进行解析并给出经典习题解答。 PS:本博客并不详解每种调度算法的原理,因此有这方面需求...
  • 高级调度(作业调度)和低级调度(进程调度)的区别 作业调度为进程被调用做准备,进程调度使进程被调用。换言之,作业调度的结果是为作业创建进程,而进程调度的结果是进程被执行。 作业调度次数少,进程调度频率高。 ...
  • 批处理作业调度

    2019-12-18 22:39:46
    批处理作业调度 临近考试,又仔细复习了一遍,感觉比以前刚刚学的时候更加深刻和理解。以下是算法思想和代码。有不对的地方请指教。 给定n个作业,每一个作业都有两项任务分别在2台机器上完成。每个作业ji必须先有...
  • 处理机调度-作业调度

    2019-11-18 16:54:00
    处理机调度-作业调度 作业调度的主要目的-两个转变 1.完成作业从后备状态到执行状态的转变 2.从执行状态到完成状态的转变 作业调度的主要功能 记录系统中各作业的状况 为了从若干的作业中挑选出一个作业来投入运行,...
  • C# 简单的作业调度

    2018-03-08 16:56:32
    ,C# 简单的作业调度,亦可参考博客:http://www.cnblogs.com/chenwolong/p/Job.html,C# 简单的作业调度,亦可参考博客:http://www.cnblogs.com/chenwolong/p/Job.html,C# 简单的作业调度,亦可参考博客:...
  • 3.1处理机调度的层次和调度算法 ...又称长程调度或作业调度。 高级调度主要用于多道批处理系统中。 ⑵低级调度 又称为进程调度或短程调度。 进程调度是基本调度,所有系统都必须配备。 ⑶中级调度(双向) 又称
  • 关于作业调度 有算法三个(先来先服务 短作业优先 最高响应比)C编译
  • 高级调度:就是作业调度,按照某种调度算法从后备作业队列中挑选作业分配主存和外设资源。并建立进程 中级调度:又称中程调度,为了提高内存利用率和系统吞吐量,将暂时不能运行的进程不再占用宝贵的内存资源,将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,657
精华内容 6,262
关键字:

作业调度