Tải bản đầy đủ
Chương 2. CÀI ĐẶT THUẬT TOÁN

Chương 2. CÀI ĐẶT THUẬT TOÁN

Tải bản đầy đủ

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
{ int i,j;

process *a,tg;
a=new process[n];
gotoxy(8,1);cout<<"Ten TT";
gotoxy(18,1);cout<<"Time XH";
gotoxy(28,1); cout<<"Time TH";
for(i=0;i{ gotoxy(10,i+2);
cout<<"P"<gotoxy(20,i+2);
cin>>a[i].timexh;
gotoxy(30,i+2);
cin>>a[i].timeth;
}
for(i=0;ifor(j=0;jif( a[j].timexh>a[j+1].timexh)
{ tg=a[j]; a[j]=a[j+1];a[j+1]=tg; };
return a;
}
2.1.2.

Thuật toán xử lý chung
Việc cài đặt thuật toán được mô phỏng theo cách làm việc của CPU và tất cả

các thuật toán con đều theo mô hình thuật toán này.
Tiến trình ở đầu danh sách sẽ được ưu tiên xử lý trước và nó chiếm dụng
CPU
tại thời điểm đó.
Việc đi kèm theo là xem xét thời gian xử lý các tiến trình đã hết chưa. Nếu đã
hết thì nghĩa là hoàn thành việc xử lý, ngược lại thì tiếp tục xử lý theo thuật toán.
Xong mỗi chu kỳ của CPU (1 quantum) thì cập nhật lại danh sách để loại bỏ
các tiến trình đã hoàn thành hay sắp xếp hay thêm các tiến trình mới vào.

13
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.

Hình 1.6: Sơ đồ thuật toán đề xuất chung cho các giải thuật
2.2. Thuật toán
Kết quả trả về là giá trị kiểu được định nghĩa cấu trúc như sau:
struct sodo
{ int *ten;
int *moc;
int sl; };
2.2.1.

Thuật toán First Come First Served(FCFS)
Code:
sodo FCFS(process *a,int &n)
{ sodo G; process *x; int i,j;
x=new process[n];
for(i=0;i14
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
x[i]=a[i];
G.sl=0;
G.ten=new int;
G.moc=new int;
G.moc[0]=0;
j=0,i=0;
cout<<"Ket qua theo thuat toan FCFS\n\n";
while(j{
G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
G.moc=(int*)realloc(G.moc,(G.sl+2)*sizeof(int));
if(G.moc[i]{ G.moc[i+1]=x[j].timexh;
G.ten[i]=0;
}
else
{ G.ten[i]=x[j].id;
G.moc[i+1]=G.moc[i]+x[j].timeth;
j++;
}
G.sl++;
i++;
}
return G; }

2.2.2.

Thuật toán Round robin(RR)
Code:
sodo RR(process *x,int &n)
{ sodo G; process *a; int i,j,q;
a=new process[n];
for(i=0;ia[i]=x[i];
int *xh,sopt=0,slxh=0,*vt,*cl;
xh=new int[n];
15
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
vt=new int;
cl=new int;
G.ten=new int;
G.moc=new int;
G.sl=0; G.moc[0]=0;
for(i=0;icout<<"Luong tu thoi gian q= "; cin>>q;
cout<<"Ket qua theo thuat toan RR\n\n";
for(i=0;iif(a[i].timexh==G.moc[0] && xh[i]==0)
{ vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
cl[sopt]=a[i].timeth;
xh[i]=1; sopt++; slxh++;
}
while(sopt>0 || slxh{ G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
G.moc=(int*)realloc(G.moc,(G.sl+2)*sizeof(int));
if(sopt>0)
{ if(cl[sopt-1]<=q)
{ G.moc[G.sl+1]=G.moc[G.sl]+cl[sopt-1];
G.ten[G.sl]=vt[sopt-1];
sopt--;
for(i=0;iif(a[i].id==G.ten[G.sl])
{ j=i;
break;
}
xh[j]=1;
}
else
{ G.moc[G.sl+1]=G.moc[G.sl]+q;
16
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
G.ten[G.sl]=vt[sopt-1];
for(i=sopt-1;i>0;i--)
{ vt[i]=vt[i-1]; cl[i]=cl[i-1];
xh[i]=xh[i-1];
}
vt[0]=G.ten[G.sl];
for(i=0;iif(a[i].id==G.ten[G.sl])
{ j=i; break; }
a[j].timeth-=q;
cl[0]=a[j].timeth;
xh[j]=1;
}
G.sl++;
}
else
{ for(i=0;iif(xh[i]==0)
{ j=i; break; }
vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[j].id;
cl[sopt]=a[j].timeth;
G.moc[G.sl+1]=a[j].timexh;
G.ten[G.sl]=0;
slxh++; sopt++;
G.sl++;
continue;
}
for(i=0;iif(a[i].timexh<=G.moc[G.sl] && xh[i]==0)
{ vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
17
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
cl[sopt]=a[i].timeth;
sopt++; slxh++; xh[i]=1;
}
}
return G;
}

2.2.3.

Thuật toán Shortest Job First(SJF)
Code:
sodo SJF(process *x,int &n)
{ sodo G; int i,j,tg; process *a;
a=new process[n];
for(i=0;ia[i]=x[i];
int *vt;
int *th;
int *cl;
int sopt=0;
int slxh=0;
int *xh;
xh=new int[n];
vt=new int;
th=new int;
cl=new int;
G.ten=new int;
G.moc=new int;
G.sl=0;
G.moc[0]=0;
for(i=0;icout<<"Ket qua theo thuat toan SJF\n\n";
while(sopt>0 || slxh{
G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
G.moc=(int*)realloc(G.moc,(G.sl+2)*sizeof(int));
18
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
for(i=0;iif (a[i].timexh<=G.moc[G.sl] && xh[i]==0)
{ vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
th=(int*)realloc(th,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
th[sopt]=a[i].timeth;
cl[sopt]=a[i].timeth;
sopt++;
slxh++;
xh[i]=1;
}
for(i=0;ifor(j=0;jif(th[j+1] >= th[j])
{ tg=vt[j]; vt[j]=vt[j+1]; vt[j+1]=tg;
tg=th[j]; th[j]=th[j+1]; th[j+1]=tg;
tg=cl[j]; cl[j]=cl[j+1]; cl[j+1]=tg;
}
if(sopt==0)
{ G.ten[G.sl]=0;
G.moc[G.sl+1]=a[slxh].timexh;
G.sl++ ;
}
else
{ G.ten[G.sl]=vt[sopt-1];
G.moc[G.sl+1]=G.moc[G.sl]+cl[sopt-1];
G.sl++;
for(i=0;iif (a[i].timexh < G.moc[G.sl] && xh[i]==0 && a[i].timeth< th[sopt-1])
{ G.moc[G.sl]=a[i].timexh;
cl[sopt-1]-=G.moc[G.sl]-G.moc[G.sl-1];
break;
}
19
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
if(i==n)
sopt--;
}
}
return G;
}

2.2.4.

Thuật toán Shortest Remain Time(SRT)

Code:
sodo SRT(process *x,int &n)
{ int i,j,tg; process *a; sodo G;
a=new process[n];
for(i=0;ia[i]=x[i];
int *vt;
int *cl;
int sopt=0;
int slxh=0;
int *xh;
xh=new int[n];
vt=new int; cl=new int;
G.ten=new int; G.moc=new int;
G.sl=0; G.moc[0]=0;
for(i=0;icout<<"Ket qua theo thuat toan SRT\n\n";
while(sopt>0 || slxh{
G.ten=(int*)realloc(G.ten,(G.sl+1)*sizeof(int));
G.moc=(int*)realloc(G.moc,(G.sl+2)*sizeof(int));
for(i=0;iif (a[i].timexh<=G.moc[G.sl] && xh[i]==0)
{ vt=(int*)realloc(vt,(sopt+1)*sizeof(int));
cl=(int*)realloc(cl,(sopt+1)*sizeof(int));
vt[sopt]=a[i].id;
cl[sopt]=a[i].timeth;
20
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.
sopt++;
slxh++;
xh[i]=1;
}
for(i=0;ifor(j=0;jif(cl[j+1] >= cl[j])
{ tg=vt[j]; vt[j]=vt[j+1]; vt[j+1]=tg;
tg=cl[j]; cl[j]=cl[j+1]; cl[j+1]=tg;
}
if(sopt==0)
{ G.ten[G.sl]=0;
G.moc[G.sl+1]=a[slxh].timexh;
G.sl++ ;
}
else
{ G.ten[G.sl]=vt[sopt-1];
G.moc[G.sl+1]=G.moc[G.sl]+cl[sopt-1];
G.sl++;
for(i=0;iif(a[i].timexh&&
a[i].timexh+G.moc[G.sl-1]>a[i].timeth))

xh[i]==0

&&(cl[sopt-1]-

{
G.moc[G.sl]=a[i].timexh;
cl[sopt-1]-=a[i].timexh-G.moc[G.sl-1];
break;
}
if(i==n)
sopt--;
}
}
return G;
}
21
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.

22
Nhóm 15 _ ĐH HTTT1 _ K6

Đề tài: Lập trình mô phỏng các phương pháp lập lịch cho CPU.

KẾT LUẬN
Qua quá trình tìm hiểu và nghiên cứu về các phương pháp lập lịch cho CPU.
Nhóm 15 chúng em đã củng cố thêm được kiến thức và hiểu biết thêm về CPU, hiểu
được tầm quan trọng và vai trò của CPU trong việc điều khiển và quản lý các tiến trình.
Nhưng điều quan trọng hơn là qua bài tập lớn lần này chúng em đã học tập được
nhiều kinh nghiệm để làm việc theo nhóm. Học hỏi được nhiều phương pháp tìm kiếm,
tra cứu thông tin. Chúng em đã tìm kiếm được nhiều thông tin bổ ích không những cho
bài tập lớn của mình mà còn nhiều thông tin bổ ích khác liên quan đến ngành học của
mình thông qua các kênh thông tin khác nhau.
Tuy nhiên, chúng em vẫn chưa có kinh nghiệm và kiến thức còn hạn chế không
thể tránh khỏi nhưng sai sót, khiếm khuyết mong thầy giáo và các bạn góp ý để chúng
em chỉnh sửa.
Chúng em xin chân thành cảm ơn!

23
Nhóm 15 _ ĐH HTTT1 _ K6