在rr演算法

Ⅰ 模擬短作業優先演算法、時間片輪轉演算法（RR）和優先數演算法的執行情況

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define LENsizeof(struct job)

struct job
{
char name[2];
int cometime;
int runtime;
int priority;
int finishtime;
int state;
struct job *next;
};

void readtxt();
void SJF();
void (structjob *,struct job *);
void RR(int);
void FPF();
void print1(structjob *);
void print2(structjob *);

int n=0;
struct job*head=NULL;
struct job*end=NULL;
FILE*fp=NULL;

void main()
{
if((fp=fopen("JOB1.txt","rb"))==NULL){
printf("can not find file\n");
exit(0);
}
while(!feof(fp)){
readtxt();
}
fclose(fp);

int x,y;
printf("請選擇進程調度演算法：\n");
printf("1.短作業優先演算法 2.時間片輪轉演算法 3.優先數演算法\n");
printf("選擇序號：");
scanf("%d",&x);
if((x!=1)&&(x!=2)&&(x!=3))printf("序號不存在！\n");
else{
switch(x){
case 1: SJF(); break;
case 2: {
printf("輸入時間片：");
scanf("%d",&y);
RR(y);
break;
}
case 3: FPF(); break;
}
}
}

void readtxt(){
struct job *p1;
p1=(struct job *)malloc(LEN);
fscanf(fp,"%s %d %d%d",(*p1).name,&((*p1).cometime),&((*p1).runtime),&((*p1).priority));
(*p1).state=0;
(*p1).finishtime=0;
if(n==0){
head=p1;
end=p1;
(*end).next=NULL;
n++;
}
else{
(*end).next=p1;
end=p1;
(*end).next=NULL;
n++;
}
}

void SJF(){
struct job *shead,*send,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).runtime<(*p1).runtime)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
shead=p;
send=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).runtime<(*p1).runtime)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*send).next=p;
send=p;
}
(*send).next=NULL;
printf("%s\n","短作業優先演算法執行結果：");
printf("%s\n","進程執行順序 周轉時間");
print1(shead);
}

void RR(intpertime){
structjob *rhead,*rend,*rrhead,*rrend,*p1,*p2,*p;
int i,curtime=0,m=0,temp1=0,temp2;
while(m!=n){
p1=head;
temp2=temp1;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).runtime!=0)&&((*p1).state!=1)){temp1++;break;}
else p1=(*p1).next;
}
if(p1!=NULL){
p2=(*p1).next;
for(i=i+1;i<n;i++){
if((((*p2).cometime<(*p1).cometime)&&((*p2).runtime!=0)&&((*p2).state!=1))||
(((*p2).cometime==(*p1).cometime)&&((*p2).priority<(*p1).priority)&&((*p2).runtime!=0)&&((*p2).state!=1)))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
}

if(temp2!=temp1){
(*p1).state=1;
p=(struct job *)malloc(LEN);
(p,p1);
if(temp1==1) {rhead=p;rend=p;}
else{
(*rend).next=p;
rend=(*rend).next;
}
}
else{
if((temp1==1)&&(m==0)){
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
}
p=(struct job *)malloc(LEN);
(p,rhead);
rrhead=p;
rrend=p;
}
else{
if(strcmp((*rhead).name,(*rrend).name)==0){
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}

}
else{
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}
}
}
}
}
(*rrend).next=NULL;
printf("%s%d%s\n","時間片輪轉演算法執行結果(時間片",pertime,")：");
print2(rrhead);
}

void FPF(){
structjob *fhead,*fend,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).priority<(*p1).priority)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
fhead=p;
fend=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).priority<(*p1).priority)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*fend).next=p;
fend=p;
}
(*fend).next=NULL;
printf("%s\n","最高優先權優先演算法執行結果(非搶占方式)：");
printf("%s\n","進程執行順序 周轉時間");
print1(fhead);
}

void (structjob *p,struct job *p1){
strcpy((*p).name,(*p1).name);
(*p).cometime=(*p1).cometime;
(*p).runtime=(*p1).runtime;
(*p).priority=(*p1).priority;
(*p).finishtime=(*p1).finishtime;
(*p).state=(*p1).state;
}

void print1(structjob *p){
while(p!=NULL){
printf("%-14s%d\n",(*p).name,(*p).finishtime-(*p).cometime);
p=(*p).next;
}
}

void print2(structjob *p){
struct job *head;
head=p;
printf("%s\n","進程執行順序");
while(head!=NULL){
printf("%3s",(*head).name);
head=(*head).next;
}
printf("\n%s\n","進程周轉時間");
head=p;
while(head!=NULL){
if(((*head).finishtime-(*head).cometime)>0)
printf("%-4s%d\n",(*head).name,(*head).finishtime-(*head).cometime);
head=(*head).next;
}
}

網上找的，自己看著辦

Ⅱ 使用RR輪詢演算法,需要配置哪個文件

需要用輔助的數組存儲信息之類的。
RR演算法用隊列直接模擬是相對很簡單的，也很適合在考試時使用，但是其它的調度演算法就不一定了，需要用輔助的數組存儲信息之類的，符合原理地適時調整。
換進程。該演算法中，將一個較小時間單元定義為時間量或時間片。時間片的大小通常為10-100ms。就緒隊列作為循環隊列。CPU調度程序循環整個就緒隊列，為每個進程分配不超過一個時間片的CPU。為了實現RR調度，我們再次將就緒隊列視為進程的FIFO隊列。新進程添加到就緒隊列的尾部。CPU調度程序從就緒隊列中選擇第一個進程，將定時器設置在一個時間片後中斷，最後分派這個進程。接下來，有兩種情況可能發生。進程可能只需少於時間片的CPU執行。對於這種情況，進程本身會自動釋放CPU。調度程序接著處理就緒隊列的下一個進程。否則，如果當前運行進程的CPU執行大於一個時間片，那麼定時器會中斷，進而中斷操作系統。然後，進行上下文切換，再將進程加到就緒隊列的尾部，接著CPU調度程序會選擇就緒隊列內的下一個進程。不過，採用RR策略的平均等待時間通常較長。假設有如下一組進程，它們在時間0到達，其CPU執行以ms計。

Ⅲ RR的分類

為了改進RR演算法的時延特性和其在變長分組環境下的不公平性，人們又提出了一些改進演算法，如加權輪詢（WRR，Weight RR），差額輪詢（DRR，Defict RR），緊急輪詢（URR，Urgency-based RR）。這些演算法都力圖在盡量保持RR演算法實現簡單性的同時，從不同的方面改進RR演算法的時延特性和其在可變長分組環境下的不公平性。 URR演算法是為改善RR演算法時延特性而提出的另一種演算法。URR個緊急性指數演算法為每個隊列分配U；在每個調度循環前，演算法首先計算各隊列的U值，然後按照U的大小順序為各隊列提供服務。盡管URR演算法改善了時延特性，但其原有的公平性問題仍然存在。

Ⅳ 考慮一種RR(時間片輪轉)調度演算法的變種,演算法中就緒隊列中存放的是指向各個進程式控制

#include 「stdio.h」
#define running 1 // 用running表示進程處於運行態
#define aready 2 // 用aready表示進程處於就緒態
#define blocking 3 // 用blocking表示進程處於阻塞態
#define sometime 5 // 用sometime表示時間片大小
#define n 10 //假定系統允許進程個數為n
struct
{
int name; //進程標識符
int status; //進程狀態
int ax,bx,cx,dx ; //進程現場信息，通用寄存器內容
int pc ; //進程現場信息，程序計數器內容
int psw; //進程現場信息，程序狀態字內容
int next; //下一個進程式控制制塊的位置
}pcbarea[n]; //模擬進程式控制制塊區域的數組
int PSW, AX,BX,CX,DX , PC ,TIME ; //模擬寄存器
int run; //定義指向正在運行進程的進程式控制制塊的指針
struct
{
int head;
int tail;
}ready; //定義就緒隊列的頭指針head和尾指針tail
int pfree; //定義指向空閑進程式控制制塊隊列的指針

scheling( ) //進程調度函數
{
int i;
if (ready.head==-1) //空閑進程式控制制塊隊列為空，退出
{
printf(「無就緒進程\n」);
return;
}
i=ready.head; //就緒隊列頭指針賦給i
ready.head=pcbarea[ready.head].next; //就緒隊列頭指針後移
if(ready.head==-1) ready.tail=-1; //就緒隊列為空，修正尾指針ready.tail
pcbarea[i].status=running; //修改進程式控制制塊狀態
TIME=sometime; //設置相對時鍾寄存器
//恢復該進程現場信息
AX=pcbarea[run].ax;
BX=pcbarea[run].bx;
CX=pcbarea[run].cx;
DX=pcbarea[run].dx;
PC=pcbarea[run].pc;
PSW=pcbarea[run].psw;
run=i;
}//進程調度函數結束

create(int x) //進程創建函數
{
int i;
if(pfree==-1) //空閑進程式控制制塊隊列為空
{
printf(「無空閑進程式控制制塊，進程創建失敗\n」);
return;
}
i=pfree; //取空閑進程式控制制塊隊列的第一個
pfree=pcbarea[pfree].next; // pfree後移
//填寫該進程式控制制塊的內容
pcbarea[i].name=x;
pcbarea[i].status=aready;
pcbarea[i].ax=x;
pcbarea[i].bx=x;
pcbarea[i].cx=x;
pcbarea[i].dx=x;
pcbarea[i].pc=x;
pcbarea[i].psw=x;
if (ready.head!=-1) //就緒隊列不為空時，掛入就緒隊列的方式
{
pcbarea[ready.tail].next=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
else //就緒隊列為空時，掛入就緒隊列的方式
{
ready.head=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
}//進程創建函數結束

main()
{ //系統初始化
int num,i,j;
run=ready.head=ready.tail =-1;
pfree=0;
for(j=0;j<n-1;j++)
pcbarea[j].next=j+1;
pcbarea[n-1].next=-1;
printf(「輸入進程編號（避免編號沖突，以負數輸入結束，最多可以創建10個進程）：\n」);
scanf(「%d」,num);
while(num>=0)
{
create(num) ;
scanf(「%d」,num) ;
}
scheling(); //進程調度
if(run!=-1)
{
printf(「進程標識符 進程狀態 寄存器內容：ax bx cx dx pc psw:\n」);
printf(「%8d%10d%3d%3d%3d%3d%3d%3d\n」, pcbarea[run].name, pcbarea[run].status, pcbarea[run].ax, pcbarea[run].bx, pcbarea[run].cx, pcbarea[run].dx, pcbarea[run].pc, pcbarea[run].psw);
}
}//main()結束
我用的是vc++6.0的，你可以試試，有不懂得在和我交流吧

Ⅳ 時間片輪轉演算法（RR）能不能用在作業調度上還是只能用在進程調度上

導師給出的答案是不能，但是吧友似乎有一些別的看法。
先來看作業調度的定義，高級調度又稱長程調度或作業調度，他的調度對象是作業。主要功能是根據演算法，決定將外存處於後備隊列的哪幾個作業調入內存，為他們創建進程，分配必要的資源，並將它們放入就緒隊列。分時和實時系統不設置高級調度。
其次簡單的敘述一下低級調度（進程調度）：對象為進程，功能是決定就緒隊列中的哪個進程應獲得處理機，並分配。
最後來看一下RR的核心，進程切換：在RR調度演算法中，應在合適進行進程的切換，可分為兩種情況：1，若一個時間片尚未用完，正在運行的進程便已經完成，立刻激活調度程序，將他從就緒隊列中刪除，再調度就緒隊列中對手的進程運行，並啟動一個新的時間片。2.在一個時間片用完時，計時調度器中斷處理程序被激活。如果進程尚未運行完畢，調度程序將把它送往就緒隊列的末尾。
可見，RR演算法在切換進程時只涉及了就緒隊列的c、a、o作，也就是只有低級調度參與，並沒有從外存將作業調入內存，另外，RR演算法常用於分時系統，分時系統也是不設置作業調度的。

Ⅵ 進程調度演算法

FCFS調度演算法屬於不可剝奪演算法。從表面上看，它對所有作業都是公平的，但若一個長作業先到達系統，就會使後面許多短作業等待很長時間，因此它不能作為分時系統和實時系統的主要調度策略。但它常被結合在其他調度策略中使用。例如，在使用優先順序作為調度策略的系統中，往往對多個具有相同優先順序的進程按FCFS原則處理。

FCFS調度演算法的特點是演算法簡單，但效率低； 對長作業比較有利，但對短作業不利（相對SJF和高響應比）；

FCFS調度演算法有利於CPU繁忙型作業，而不利於I/O繁忙型作業。

​ 短作業優先調度演算法是一個非搶占策略，他的原則是下一次選擇預計處理時間最短的進程，因此短進程將會越過長作業，跳至隊列頭。該演算法即可用於作業調度，也可用於進程調度。 但是他對長作業不利，不能保證緊迫性作業（進程）被及時處理，作業的長短只是被估算出來的。

缺點：

該演算法對長作業不利，SJF調度演算法中長作業的周轉時間會增加。更嚴重的是，如果有一長作業進入系統的後備隊列，由於調度程序總是優先調度那些 (即使是後進來的）短作業，將導致長作業長期不被調度（「飢餓」現象，注意區分「死鎖」。後者是系統環形等待，前者是調度策略問題）。

該演算法完全未考慮作業的緊迫程度，因而不能保證緊迫性作業會被及時處理。

由於作業的長短只是根據用戶所提供的估計執行時間而定的，而用戶又可能會有意或無意地縮短其作業的估計運行時間，致使該演算法不一定能真正做到短作業優先調度。

SJF調度演算法的平均等待時間、平均周轉時間最少。

高響應比優先調度演算法既考慮作業的執行時間也考慮作業的等待時間，綜合了先來先服務和最短作業優先兩種演算法的特點。

該演算法中的響應比是指作業等待時間與運行比值，響應比公式定義如下：

響應比 =（等待時間+要求服務時間）/ 要求服務時間,即RR=（w+s）/s=1+w/s，因此 響應比一定是大於等於1的。

短作業與先後次序的兼顧，且不會使長作業長期得不到服務。

響應比計算系統開銷，增加系統開銷。

高響應比優先調度演算法適合批處理系統，主要用於作業調度。

為了實現 RR 調度，我們將就緒隊列視為進程的 FIFO 隊列。新進程添加到就緒隊列的尾部。CPU 調度程序從就緒隊列中選擇第一個進程，將定時器設置在一個時間片後中斷，最後分派這個進程。

接下來，有兩種情況可能發生。進程可能只需少於時間片的 CPU 執行。對於這種情況，進程本身會自動釋放 CPU。調度程序接著處理就緒隊列的下一個進程。否則，如果當前運行進程的 CPU 執行大於一個時間片，那麼定時器會中斷，進而中斷操作系統。然後，進行上下文切換，再將進程加到就緒隊列的尾部，接著 CPU 調度程序會選擇就緒隊列內的下一個進程。

採用 RR 策略的平均等待時間通常較長。

在 RR 調度演算法中，沒有進程被連續分配超過一個時間片的 CPU（除非它是唯一可運行的進程）。如果進程的 CPU 執行超過一個時間片，那麼該進程會被搶占，並被放回到就緒隊列。因此， RR調度演算法是搶占的。

演算法描述

1、進程在進入待調度的隊列等待時，首先進入優先順序最高的Q1等待。

2、首先調度優先順序高的隊列中的進程。若高優先順序中隊列中已沒有調度的進程，則調度次優先順序隊列中的進程。例如：Q1,Q2,Q3三個隊列，當且僅當在Q1中沒有進程等待時才去調度Q2，同理，只有Q1,Q2都為空時才會去調度Q3。

3、對於同一個隊列中的各個進程，按照FCFS分配時間片調度。比如Q1隊列的時間片為N，那麼Q1中的作業在經歷了N個時間片後若還沒有完成，則進入Q2隊列等待，若Q2的時間片用完後作業還不能完成，一直進入下一級隊列，直至完成。

4、在最後一個隊列QN中的各個進程，按照時間片輪轉分配時間片調度。

5、在低優先順序的隊列中的進程在運行時，又有新到達的作業，此時須立即把正在運行的進程放回當前隊列的隊尾，然後把處理機分給高優先順序進程。換而言之，任何時刻，只有當第1~i-1隊列全部為空時，才會去執行第i隊列的進程（搶占式）。特別說明，當再度運行到當前隊列的該進程時，僅分配上次還未完成的時間片，不再分配該隊列對應的完整時間片。

Ⅶ 急求一個c語言程序後天就要用了麻煩各位好心高手幫幫忙。謝謝。

#include<reg51.h>
#define uchar unsigned char
#define uint unsigned int

uint Tcounetr=0;
unsigned long int mm=0;
sbit P1_6=P1^6;
sbit P1_7=P1^7;

uchar code table[]={0xc0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,}; //設置字元代碼

delay(uint m) //延時1ms程序
{ uint i,j;
for(i=m;i>0;i--)
for(j=60;j>0;j--);
}

xian_shi() //顯示程序
{ uchar ,shi,ge,xiaoshu;
unsigned long int k=14,h=36;
unsigned long int jj;
jj=mm*k*h;
=jj/1000000;
shi=jj%1000000/100000;
ge=jj%100000/10000;
xiaoshu=jj%10000/1000;

P2=0xE0;
P0=table[];
delay(1);
P2=0XF0;

P2=0xD0;
P0=table[shi];
delay(1);
P2=0XF0;

P2=0xB0;
P0=table[ge];
delay(1);
P2=0XF0;

P2=0x70;
P0=table[xiaoshu];
delay(1);
P2=0XF0;
}
timer_init() //定時器計數器初始化函數
{ EA=1;
ET0=1;
ET1=1;
TMOD=0X51;
TH0=0XB1;
TL0=0XE0;
TH1=0;
TL1=0;
TR0=1;
TR1=1;
}
main() //主函數
{
timer_init();
P0=0; //開始數碼管不顯示
while(1)
{
xian_shi();
delay(2); //數碼管刷新時間單位毫秒
}
}
void timer0() interrupt 1 //定時器0中斷
{ uchar a;
TR0=0;
TH0=0XB1;
TL0=0XE0;
Tcounetr++;
if(Tcounetr>=50)
{ TR1=0;
Tcounetr=0;
a=TH1;
mm=a*256+TL1;
if(mm>=1984)
if(mm>=3000)
P1_7=0,
P1_6=0;
else
P1_7=0;
else
P1=0XFF;
TH1=0;
TL1=0;
TR1=1;
}
TR0=1;
}
void timer1() interrupt 3 //計數器1中斷時出錯
{ TR1=0;
TR0=0;
mm=0;
TH0=0XB1;
TL0=0XE0;
TH1=0;
TL1=0;
TR0=1;
TR1=1;

Ⅷ RR是什麼

R是電阻！！！！！！電阻！！！

Ⅸ 處理機調度可以分為

在多道程序設計系統中，內存中有多道程序運行，他們相互爭奪處理機這一重要的資源。處理機調度就是從就緒隊列中，按照一定的演算法選擇一個進程並將處理機分配給它運行，以實現進程並發地執行。
1.處理機調度的功能
一般情況下，當佔用處理機的進程因為某種請求得不到滿足二不得不放棄CPU進入等待狀態時，或者當時間片到，系統不得不將CPU分配給就緒隊列中另以進程的時候，都要引起處理機調度。除此之外，進程正常結束、中斷處理等也可能引起處理機的調度。因此，處理機調度是操作系統核心的重要組成部分，它的主要功能如下：
（1）記住進程的狀態，如進程名稱、指令計數器、程序狀態寄存器以及所有通用寄存器等現場信息，將這些信息記錄在相應的進程式控制制塊中。
（2）根據一定的演算法，決定哪個進程能獲得處理機，以及佔用多長時間。
（3）收回處理機，即正在執行的進程因為時間片用完或因為某種原因不能再執行的時候，保存該進程的現場，並收回處理機。
處理機調度的功能中，很重要的一項就是根據一定演算法，從就緒隊列中選出一個進程佔用CPU運行。可見，演算法是處理機調度的關鍵。
2.處理機調度的性能准則
處理機調度，有許多不問的調度演算法，不同的調度演算法具有不同的特性。因此，再介紹演算法之前，先介紹衡量一個演算法的基本准則。
衡量喝比較調度演算法性能優劣主要有一下幾個因素：
（1）CPU利用率。CPU是計算機系統中最重要的資源，所以應盡可能使CPU保持忙，使這一資源利用率最高。
（2）吞吐量。CPU運行時表示系統正處於工作狀態，工作量的大小是以每單位時間所完成的昨夜樹木來描述的，這就叫吞吐量。
（3）周轉時間。指從作業提交到作業完成所經過的時間，包括作業等待，在就緒隊列中排隊，在處理機上運行以及進行輸入/輸出操作所花時間的總和。
（4）等待時間。處理機調度演算法實際上並不影響作業執行或輸入/輸出操作的時間，隻影響作業在就緒隊列中等待所花的時間。因此，衡量一個調度演算法優劣常常簡單的考察等待時間。
（5）響應時間。指從作業提交到系統作出相應所經過的時間。在互動式系統中，作業的周轉時間並不一定是最好的衡量准則，因此，常常使用另一種度量准則，即相應時間。從用戶觀點看，相應時間應該快一點好，但這常常要犧牲系統資源利用率為代價。
3.處理機調度演算法
1）先來先服調度演算法（FIFO）
這是最簡單的處理機調度演算法，其基本思想是按照進程進入就緒隊列的先後順序調度並分配處理機執行。先來先服務調度演算法是一種不可搶占的演算法，先進入就緒隊列的進程，先費培處理機運行。一旦一個進程佔有了處理機，它就一直運行下去，知道該進程完成工作或者因為等待某事件而不能繼續運行時才釋放處理機。
從表面上看，FIFO演算法對所有作業都是公平的，並且一個作業的等待時間時可能預先估計的。但實際上這種演算法是不利於小作業的，因為當一個大作業先進入就緒隊列時，就會使其後的許多小作業等待很長的時間。這對小作業來說，等待時間可能要遠遠超出它運行的時間。
先來先服演算法簡單，易於程序實現，但它性能較差，在實際運行的操作系統中，很少單獨使用，它常常配合其他調度演算法一起使用。
2）時間片輪轉調度演算法（RR）
時間片輪轉調度演算法的基本思想是：對就緒隊列中的每一進程部分配一個時間片，時間片的長度q一般從10ms-1100ms不等。把就緒隊列堪稱時一個環狀結構，調度程序按時間片長度q輪流電鍍就緒隊列中的每一進程，使每一進程都有機會獲得相同長度的時間佔用處理機運行。
時間片輪轉調度演算法在分時系統中，時一種既簡單又有效的調度策略。一個分時系統又許多中斷。中斷用戶在各自的中斷設備上同時使用計算機。如果某個中斷用戶的程序長時間的暫用處理機，那麼其他中斷用戶的請求就不能得到即使相應。一般說來，中斷用戶提出請求後，能在幾秒鍾內得到相應也就感到滿意了。採用時間片輪轉演算法，可以使系統即使的相應各中斷用戶的請求。
時間片輪轉調度演算法的性能極大的以來於時間片長度q的取值，如果時間片過大。則RR演算法就退化為FIFO演算法了；反之，如果時間片過小，那麼，處理機在各進程之間頻繁轉接，處理機時間開銷變得很大，而提供給用戶程序的時間將大大減少。

Ⅹ 請問心電圖中的「RR」代表什麼能代表什麼謝謝

(1)心電圖紙上的每個小方格，橫格為0.04s，縱格為0.1mv。
1^
R1D4[9o2r-vi8t0(2)心率：竇性心律，正常為60-100bpm之間，超過100bpm的為竇性心動過速，低於60bpm的為竇性心動過緩。在一定范圍內低於或高於正常頻率的，以及輕度的竇性心律不齊，都屬於正常范圍的心律。愛愛醫網`pM;i
~;D
Dv
(3)心律；健康人絕大多數時間為正常竇性心律，偶有早搏等
(4)P波：在肢體導聯中除avR為倒置外，余導聯多為直立，或較低平。在胸壁導聯V1-6，多不夠明顯直立。
(5)P-R間期：自P波開始至QRS波群開始的時間。正常范圍為0.12-0.20s。
(6)QRS波群：為一狹窄，形態多樣的(qR，R，Rs，rs，或qRs)波群，時間在0.06-0.10s的狹窄范圍內。
(7)ST段：是自QRs波群終了的J點開始至T波開始的一段。正常形態是隨T波的直立而淺淺的上飄。ST段平行的壓低或斜向下的壓低不正常，輕度抬高可見於正常人，應與臨床情況結合判斷正常與否。
(8)T波：除在avR導聯是例置外，余在R波高於0.5mv時均應直立。(如在I，II導聯應直立，avR中應倒置，胸前導聯自V4-6均直立)。
(9)U波：T波後的小波，在V2-3中易見，正常應直立，其它導聯可不明顯。愛愛醫網6R6AO7ySC7U:ir
(10)Q-T間期：自QRS波開始至T波終了的間期。Q-T間期隨心率而略有長短之別。但Q-T間期與心率不符合的延長有較重要意義。異常縮短多為葯物或電解質紊亂影響。
uq.aR.yK8}03、
心率的計算：
標准心電圖紙橫向表示時間，在25mm/s的紙速時一個小格是0.04秒，一個大格是0.20秒。1分鍾是300個大格。
⑴在心律規則時計算心率
計算公式是HR=60/1個心動周期的持續時間（S），在心電圖上，這個公式的分母是0.04×一個RR間期包含的小格數。簡便一些的演算法是測量一個RR間期的大格數（可以精確到小數點後兩位），因為在心電圖上1分鍾是300個大格，所以HR=300/一個RR間期的大格數。由此可以推算出下表：
一個RR間期的大格數
心率
1
300
2
150
3
100
4
75
5
60
6
50
7.5
40
……
……
⑵在心律不規則時計算心率
心律不規則時RR間期不等，應用上述公式計算心率顯然不準確。我們需要獲得一個時間段內RR間期的平均時間來計算心率。通常的計算公式是：HR=60/10個RR間期的平均時間，或者6秒內的QRS出現次數×10