Paging – LRU – FIFO – Clock – Belady

Standard
Source Code in C

A)ΑΛΓΟΡΙΘΜΟΙ ΑΝΤΙΚΑΤΑΣΤΑΣΗΣ ΣΕΛΙΔΩΝ
Όταν προκύψει κάποιο σφάλμα σελίδας το λειτουργικό σύστημα πρέπει να διαλέξει μια σελίδα και να την αφαιρέσει από την μνήμη για να εξοικονομήσει χώρο στην μνήμη για την νέα σελίδα που θα φέρει.
Υπάρχουν οι εξής στρατηγικές αντικατάστασης σελίδων ιδεατής μνήμης:

1.ΑΛΓΟΡΙΘΜΟΣ ΤΥΧΑΙΑΣ ΕΠΙΛΟΓΗΣ.
Διαλέγεται μια τυχαία σελίδα από την μνήμη για να πραγματοποιηθεί
η αντικατάσταση της από την νέα σελίδα .Είναι ο πιο απλός αλγόριθμος,
όχι ο χειρότερος αλλά ούτε και ο καλύτερος.

2.ΑΛΓΟΡΙΘΜΟΣ  FIFO.
Στον αλγόριθμο αντικατάστασης σελίδας FIFO το λειτουργικό σύστημα
διατηρεί μια λίστα με τις σελίδες που βρίσκονται στην μνήμη. Στην αρχή της λίστας βρίσκεται η παλαιότερη σελίδα και στην ουρά της η τελευταία που εμφανίστηκε. Όταν συμβαίνει σφάλμα σελίδας η σελίδα που βρίσκεται στην αρχή της λίστας αφαιρείται και η νέα σελίδα προστίθεται στην ουρά της λίστας.

3.ΑΛΓΟΡΙΘΜΟΣ  LRU.
Ο αλγόριθμος LRU βασίζεται στην παρατήρηση ότι οι σελίδες που
χρησιμοποιούνται πολύ στις τελευταίες εντολές θα χρησιμοποιηθούν πιθανότατα πολύ και στις επόμενες. Αντίστροφα σελίδες που δεν έχουν χρησιμοποιηθεί για  πολύ καιρό πιθανότατα θα παραμείνουν στο μέλλον αχρησιμοποίητες για μεγάλο χρονικό διάστημα. Όταν προκύπτει σφάλμα σελίδας αφαιρείται η σελίδα που δεν έχει χρησιμοποιηθεί για το μεγαλύτερο χρονικό διάστημα. Για αυτό και η στρατηγική αυτή ονομάζεται σελιδοποίηση LRU (Least Recently Used) και προτείνει την αφαίρεση της σελίδας  που χρησιμοποιήθηκε λιγότερο πρόσφατα.
Αν και ο αλγόριθμος LRU είναι θεωρητικά πραγματοποιήσιμος δεν είναι εύκολο να υλοποιηθεί. Για να υλοποιηθεί πλήρως χρειάζεται να διατηρείται μια συνδεδεμένη λίστα με όλες τις σελίδες που βρίσκονται στη μνήμη, να τοποθετείται η σελίδα που χρησιμοποιήθηκε πιο πρόσφατα στην αρχή της λίστας και αυτή που χρησιμοποιήθηκε πιο παλιά από όλες στο τέλος. Η δυσκολία είναι ότι η λίστα πρέπει να ενημερώνεται μετά από κάθε αναφορά στην μνήμη. Η εύρεση μιας σελίδας στην λίστα, η διαγραφή της και η μετακίνηση της στην αρχή είναι ενέργειες που χρειάζονται πολύ χρόνο, ακόμη και εάν χρησιμοποιηθεί υλικό. Παρόλα αυτά υπάρχουν και άλλο τρόποι για να υλοποιηθεί ο αλγόριθμος LRU με εξειδικευμένο υλικό.

4.ΑΛΓΟΡΙΘΜΟΣ CLOCK.
Στον αλγόριθμο clock διατηρούνται όλες οι σελίδες σε μια κυκλική λίστα η
οποία έχει μορφή ρολογιού. Ένας  δείκτης δείχνει στην παλαιότερη σελίδα. Όταν προκύψει σφάλμα σελίδας ελέγχεται η σελίδα στην οποία δείχνει ο δείκτης.Αν το bit A είναι 0, η σελίδα αφαιρείται και η νέα σελίδα εισάγεται στην θέση της μέσα στο ρόλοι, ενώ ο δείκτης προχωρεί κατά μια θέση. Αν το bit Α είναι 1, τότε γίνεται 0 και ο δείκτης προχωρεί στην επόμενη σελίδα. Αυτή η διαδικασία επαναλαμβάνεται μέχρι να βρεθεί κάποια σελίδα που να έχει την τιμή 0 στο bit Α της.

Β) ΤΟ ΠΑΡΑΔΟΞΟ ΤΟΥ BELADY
Διαισθητικά, μπορεί να σχηματιστεί η εντύπωση ότι όσο περισσότερα πλαίσια σελίδας βρίσκονται στην μνήμη τόσο λιγότερα σφάλματα σελίδας θα προκύψουν κατά την εκτέλεση ενός προγράμματος. Οι Belady ανακάλυψαν ένα αντιπαράδειγμα στο οποίο ο αλγόριθμος FIFO προκαλεί περισσότερα σφάλματα σελίδας όταν υπάρχουν τέσσερα πλαίσια σελίδας,παρά όταν υπάρχουν τρία. Αυτή η περίεργη κατάσταση ονομάστηκε παράδοξο του Belady.Το παράδοξο του Belady οφείλεται κυρίως στα προβλήματα που παρουσιάζει ο αλγόριθμος FIFO.Ο FIFO παρακολουθεί τη σειρά με την οποία οι σελίδες φορτώνονται στην μνήμη, διατηρώνταςτες σε μια συνδεδεμένη λίστα.Η αφαίρεση της παλαιότερης σελίδας είναι απλή υπόθεση αλλά υπάρχει πιθανότητα η σελίδα αυτή να χρησιμοποιείται ακόμη ή η σελίδα αυτή να χρησιμοποιείται συχνά.Έτσι το βασικό μειονέκτημα του αλγόριθμου FIFO είναι η αφαίρεση σημαντικών σελίδων.

Έστω το παρακάτω παράδειγμα στοιχειοσειράς που δίνει το παράδοξο του Belady όταν τα page frames αυξάνουν από 6 σε 7:
1 2 3 4 5 6 7 1 2 8 1 2 3 4 5 6 7 8 1 2 3 4 5
Μπορούμε να γενικεύσουμε την μέθοδο εύρεσης μιας τέτοιας στοιχειοσειράς όταν ο αριθμός των page frames αυξάνει σε N δημιουργούμε μια στοιχειοσειρά από αναφορές 1..N ακολουθούμενη από 1 2 N+1 και μετά από 1..N+1.

Γ) ΥΠΟΛΟΓΙΣΜΟΣ ΧΡΟΝΟΥ ΜΕ ΧΡΗΣΗ CACHE MEMORY.
Οταν χρησιμοποιουμε cache memory τοτε αποθηκευουμε σε αυτην τις σελιδες που χρησιμοποιουνται πιο συχνα.Ετσι οταν αργοτερα χρειαστει μια σελιδα θα γινει πρωτα αναζητηση στην cache και εαν βρεθει τοτε θα διαβαστει απο εκει αλλιως θα προστεθει στην cache και θα γινει αναζητηση στην κυρια μνημη.Οπως και με την ιδεατη μνημη ετσι και εδω μπορουμε να χρησιμοποιησουμε τις ιδιες τεχνικες αντικαταστασης σελιδων. Η χρηση της cache memory μειωνει αισθητα το χρονο της εκτελεσης των στοιχειoσειρων(reference strings).

1.pages.h
Αρχείο επικεφαλίδα το οποίο περιέχει τις δηλώσεις των συναρτήσεων που θα χρησιμοποιηθούν στο πρόγραμμα καθώς και τις δηλώσεις των καθολικών μεταβλητών και σταθερών.

 1: #ifndef PAGE_H
 2: #define PAGE_H
 3: /*** Αρχειο page.h - Paging Header File. ***/
 4: /* ----------------------- *
 5:  * Κωνσταντίνος Χαλβαντζής *
 6:  * ----------------------- *
 7:  * Α.Μ. : 018200100093 *
 8:  **********************************************/
 9:  
 10: /*Ορισμος του μεγιστου αριθμου αναφορων στο reference string*/
 11: #define MAXRS 90000000
 12: 
 13: /*Δεικτης για τα αρχεια log*/
 14: FILE *file_ptr;
 15:  
 16: /*Ακεραιοι pf=page frames ,MAX=μεγεθος πινακα RS ,cf=cache frames*/
 17: int pf,MAX,cf;
 18: 
 19: /*Πινακες Μ= Main Memory , CM= Cache Memory*/
 20: int *M,*CM;
 21:  
 22: /*Πινακας RS με μεγιστο μεγεθος MAXRS και πραγματικο MAX.Αποθηκευει τα στοιχεια του reference string*/
 23: int RS[MAXRS];
 24: 
 25: /*Αλγοριθμος αντικαταστασης σελιδων τυχαιας επιλογης*/
 26: void random1(int *M,int *RS,int MAX);
 27:  
 28: /*Αλγοριθμος αντικαταστασης σελιδων FIFO*/
 29: void fifo(int *M,int *RS,int MAX);
 30: 
 31: /*Αλγοριθμος αντικαταστασης σελιδων LRU*/
 32: void lru(int *M,int *RS,int MAX);
 33:  
 34: /*Αλγοριθμος αντικαταστασης σελιδων CLOCK*/
 35: void clock(int *M,int *RS,int MAX);
 36: 
 37: /*Συναρτηση αναζητησης στοιχειου σε πινακα*/
 38: void anazitisi(int kleidi,int megethos,int pinakas[],int *deiktis,int *vrethike);
 39:  
 40: /*Συναρτηση δημιουργιας των αρχειων log*/
 41: void createfile(int selection,int page,int replace_page);
 42: 
 43: /*Συναρτηση εγγραφης των page faults στα αρχεια log*/
 44: void page_faultfile(int selection,int page_faults);
 45:  
 46: /*Συναρτηση επιλογης της μεθοδου αντικαταστασης σελιδων*/
 47: void selection(char *select);
 48: 
 49: /*Συναρτηση παρουσιασης του παραδοξου του Belady μαζι με γραφικες παραστασεις 
 50: για τα page faults ανα page frames*/
 51: void belady();
 52: 
 53:  
 54: 
 55: #endif
 56: 2.paging.c
 57:     Αρχείο το οποίο περιέχει τον ορισμό-υλοποίηση των συναρτήσεων που θα 
 58:     χρησιμοποιηθούν στο πρόγραμμα και έχουν δηλωθεί στο αρχείο pages.h.
 59: /*** Αρχειο paging.c - Paging Συναρτησεις. ***/
 60: /* ----------------------- *
 61:  * Κωνσταντίνος Χαλβαντζής *
 62:  * ----------------------- *
 63:  * Α.Μ. : 018200100093 *
 64:  ********************************************/
 65: #include <stdio.h>
 66: #include <stdlib.h>
 67: #include "pages.h"
 68: 
 69:  
 70: /*Αλγοριθμος τυχαιας αντικαταστασης σελιδων.Διαλέγεται μια τυχαία σελίδα 
 71: από την μνήμη για να πραγματοποιηθεί η αντικατάσταση της από την νέα σελίδα.
 72: Διαβαζονται οι αναφορες του reference string απο τον πινακα RS και τοποθετουνται 
 73: στα page frames της Main memory με τυχαια επιλογη. */
 74: 
 75: void random1(int *M,int *RS,int MAX) //exei problhma sto teleytaio page_fault
 76: {
 77:     int i,r,page_faults;
 78:     int deiktis=0;
 79:     int vrethike=0;
 80:     int j=1;
 81:     i=1;
 82:     page_faults=0;
 83:  
 84:     while(i<=MAX && j<=pf) //Εισαγωγη αναφορων στα page frames οσο αυτα ειναι κενα.
 85:     {
 86:         anazitisi(RS[i],pf,M,&deiktis,&vrethike);
 87:         if(vrethike==0)
 88:         {
 89:             page_faults++;
 90:             createfile(1,M[j],RS[i]);
 91:             M[j]=RS[i];
 92:             j++;
 93:         }
 94:         i++;
 95:     }
 96: 
 97:     while(i<=MAX) 
 98:     {
 99:         anazitisi(RS[i],pf,M,&deiktis,&vrethike);
 100:         if(vrethike==0)
 101:         {
 102:             page_faults++;
 103:             r=rand()%pf;   //Τυχαια επιλογη του δεικτη r.
 104:             r=r+1;
 105:             if(r!=0)
 106:             {
 107:                 createfile(1,M[r],RS[i]);
 108:                 M[r]=RS[i];        //Τυχαια αντικατασταση σελιδας στο page frame ετσι οπως επιλεγεται απο τον δεικτη r.
 109:             }
 110:         }
 111:         i++;
 112:     }
 113:     page_faultfile(1,page_faults);
 114: }
 115:  
 116: 
 117:  
 118: ////////////////////////////////////////////////////////////////
 119:  
 120: /*Στον αλγόριθμο αντικατάστασης σελίδας FIFO το λειτουργικό σύστημα διατηρεί 
 121: μια λίστα με τις σελίδες που βρίσκονται στην μνήμη. Στην αρχή της λίστας βρίσκεται 
 122: η παλαιότερη σελίδα και στην ουρά της η τελευταία που εμφανίστηκε. Όταν συμβαίνει 
 123: σφάλμα σελίδας η σελίδα που βρίσκεται στην αρχή της λίστας αφαιρείται και η νέα σελίδα 
 124: προστίθεται στην ουρά της λίστας.*/
 125:  
 126: void fifo(int *M,int *RS,int MAX)
 127: {
 128:     int i,r,page_faults;
 129:     int deiktis=0;
 130:     int vrethike=0;
 131:     int j=1;
 132:     i=1;
 133:     page_faults=0;
 134: 
 135:     r=1;
 136:     while(i<=MAX)
 137:     {
 138:         anazitisi(RS[i],pf,M,&deiktis,&vrethike);
 139:         if(vrethike==0)
 140:         {
 141:             page_faults++;
 142:             if (r<=pf)
 143:             {
 144:                 createfile(2,M[r],RS[i]);
 145:                 M[r]=RS[i];
 146:                 r++;
 147:             }
 148:             if(r>pf)
 149:             {
 150:                 r=1;
 151:             }
 152:         }
 153:         i++;
 154:     }
 155:     page_faultfile(2,page_faults);
 156: }
 157:  
 158: 
 159: //////////////////////////////////////////////////////////////
 160: 
 161: /*Ο αλγόριθμος LRU βασίζεται στην παρατήρηση ότι οι σελίδες που χρησιμοποιούνται 
 162: πολύ στις τελευταίες εντολές θα χρησιμοποιηθούν πιθανότατα πολύ και στις επόμενες. 
 163: Αντίστροφα σελίδες που δεν έχουν χρησιμοποιηθεί για πολύ καιρό πιθανότατα θα 
 164: παραμείνουν στο μέλλον αχρησιμοποίητες για μεγάλο χρονικό διάστημα. Όταν προκύπτει 
 165: σφάλμα σελίδας αφαιρείται η σελίδα που δεν έχει χρησιμοποιηθεί για το μεγαλύτερο 
 166: χρονικό διάστημα. Για αυτό και η στρατηγική αυτή ονομάζεται σελιδοποίηση LRU (Least Recently Used) 
 167: και προτείνει την αφαίρεση της σελίδας που χρησιμοποιήθηκε λιγότερο πρόσφατα. */
 168: 
 169: void lru(int *M,int *RS,int MAX)
 170: {
 171:     int i,k,r,page_faults;
 172:     int deiktis=0;
 173:     int vrethike=0;
 174:     int j=1;
 175:     i=1;
 176:     page_faults=0;
 177:  
 178:     while(i<=MAX)
 179:     {
 180:         anazitisi(RS[i],pf,M,&deiktis,&vrethike);
 181:         if(vrethike==1)
 182:         {
 183:             r=deiktis;
 184:             for(k=r;k<pf;k++)
 185:             {
 186:                 M[k]=M[k+1];
 187:             }
 188:             M[pf]=RS[i];
 189:         }
 190:         if(vrethike==0)
 191:         {
 192:             page_faults++;
 193:             createfile(3,M[1],RS[i]);
 194:             for(k=1;k<pf;k++)
 195:             {
 196:                 M[k]=M[k+1];
 197:             }
 198:             M[pf]=RS[i];
 199:         }
 200:         i++;
 201:     }
 202:     page_faultfile(3,page_faults);
 203: }
 204: 
 205: /////////////////////////////////////////////////////////////////
 206: 
 207: /*Στον αλγόριθμο clock διατηρούνται όλες οι σελίδες σε μια κυκλική λίστα η 
 208: οποία έχει μορφή ρολογιού. Ένας δείκτης δείχνει στην παλαιότερη σελίδα. 
 209: Όταν προκύψει σφάλμα σελίδας ελέγχεται η σελίδα στην οποία δείχνει ο δείκτης. 
 210: Αν το bit A είναι 0, η σελίδα αφαιρείται και η νέα σελίδα εισάγεται στην θέση 
 211: της μέσα στο ρόλοι, ενώ ο δείκτης προχωρεί κατά μια θέση. Αν το bit Α είναι 1, 
 212: τότε γίνεται 0 και ο δείκτης προχωρεί στην επόμενη σελίδα. Αυτή η διαδικασία 
 213: επαναλαμβάνεται μέχρι να βρεθεί κάποια σελίδα που να έχει την τιμή 0 στο bit Α της.*/
 214: 
 215: void clock(int *M,int *RS,int MAX)
 216: {
 217:     int i,r,page_faults;
 218:     int deiktis=0;
 219:     int vrethike=0;
 220:     int j=1;
 221:     int *rbit;
 222:     rbit=malloc(pf*sizeof(int));
 223:     i=1;
 224:     page_faults=0;
 225:  
 226:     r=1;
 227:     while(i<=MAX)
 228:     {
 229:         anazitisi(RS[i],pf,M,&deiktis,&vrethike);
 230:         if(vrethike==1)
 231:         {
 232:             rbit[deiktis]=1;
 233:         }
 234:         if(vrethike==0)
 235:         {
 236:             for(j=r;j<=pf;j++)
 237:             {
 238:                 if((rbit[j]==0) || (M[j]<=0))
 239:                 {
 240:                     page_faults++;
 241:                     createfile(4,M[j],RS[i]);
 242:                     M[j]=RS[i];
 243:                     rbit[j]=1;
 244:                     r=j+1;
 245:                     if(r>pf)
 246:                     {
 247:                         r=1;
 248:                     }
 249:                     break;
 250:                 }
 251:                 else 
 252:                 {
 253:                     if(rbit[j]==1)
 254:                     {
 255:                         rbit[j]=0;
 256:                     }
 257:                 }
 258:                 if(j==pf)
 259:                 {
 260:                     j=0;
 261:                 }
 262:             }
 263:         }
 264:         i++;
 265:     }
 266:     page_faultfile(4,page_faults);
 267: }
 268: 
 269: /////////////////////////////////////////////////////////////////
 270: 
 271: /*Δημιουργει τα αρχεια log για καθε μεθοδο ξεχωριστα. Σε καθε ενα απο αυτα σημειωνεται 
 272: ποια σελιδα αντικατασταθηκε απο ποια κατα την εμφανιση ενος page fault.*/
 273:  
 274: void createfile(int selection,int page,int replace_page)
 275: {
 276: 
 277:     FILE *Fileptr;
 278: 
 279:     switch (selection)
 280:     {
 281:     case 1:
 282:         Fileptr=fopen("logRAND","a");
 283:         fprintf(Fileptr,"===============\n");
 284:         break;
 285:     case 2:
 286:         Fileptr=fopen("logFIFO","a");
 287:         fprintf(Fileptr,"===============\n");
 288:         break;
 289:     case 3:
 290:         Fileptr=fopen("logLRU","a");
 291:         fprintf(Fileptr,"==============\n");
 292:         break;
 293:     case 4:
 294:         Fileptr=fopen("logCLOCK","a");
 295:         fprintf(Fileptr,"================\n");
 296:         break;
 297:     default:
 298:         break;
 299:     }
 300: 
 301:     if(page<0)
 302:     {
 303:         fprintf(Fileptr,"Page is NULL\n");
 304:     }
 305:     else
 306:     {
 307:         fprintf(Fileptr,"Page is %d\n",page);
 308:     }
 309:     fprintf(Fileptr,"Replace Page is %d\n\n",replace_page);
 310:     fclose(Fileptr);
 311:         
 312: 
 313: }
 314: ////////////////////////////////////////////////////////////////////////
 315:  
 316: /*Σημειωνει σε καθε ενα αρχειο log για καθε μεθοδο ξεχωριστα τον συνολικο αριθμο των page faults.*/
 317:  
 318: void page_faultfile(int selection,int page_faults)
 319: {
 320:     FILE *Fileptr;
 321:     switch (selection)
 322:     {
 323:     case 1:
 324:         Fileptr=fopen("logRAND","a");
 325:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ ΤΥΧΑΙΑΣ ΕΠΙΛΟΓΗΣ-random1\n");
 326:         fprintf(Fileptr,"==================================\n");
 327:         break;
 328:     case 2:
 329:         Fileptr=fopen("logFIFO","a");
 330:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ FIFO\n");
 331:         fprintf(Fileptr,"===============\n");
 332:         break;
 333:     case 3:
 334:         Fileptr=fopen("logLRU","a");
 335:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ LRU\n");
 336:         fprintf(Fileptr,"==============\n");
 337:         break;
 338:     case 4:
 339:         Fileptr=fopen("logCLOCK","a");
 340:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ CLOCK\n");
 341:         fprintf(Fileptr,"================\n");
 342:         break;
 343:     default:
 344:         break;
 345:     }
 346:     fprintf(Fileptr,"Page Faults are %d\n",page_faults);
 347:     fclose(Fileptr);
 348: }
 349:  
 350: ///////////////////////////////////////////////////////////////////
 351: /*Συναρτηση για την επιλογη της καταλληλης μεθοδου αντικαταστασης σελιδων ετσι 
 352: οπως αυτη δηλωνεται απο την γραμμη εντολων*/
 353:  
 354: void selection(char *select)
 355: {
 356: 
 357:     switch (*select)
 358:     {
 359:         case '1':
 360:             random1(M,RS,MAX);
 361:             break;
 362:         case '2':
 363:             fifo(M,RS,MAX);
 364:             break;
 365:         case '3':
 366:             lru(M,RS,MAX);
 367:             break;
 368:         case '4':
 369:             clock(M,RS,MAX);
 370:             break;
 371:         default:
 372:             printf("Lathos Epilogi(Epilekste anamesa se 1-4)");
 373:             break;
 374:     }
 375: }
 376: 
 377: //////////////////////////////////////////////////////////////////
 378: 
 379: /*Συναρτηση αναζητησης ενος στοιχειου σε εναν πινακα*/
 380: 
 381: void anazitisi(int kleidi,int megethos,int pinakas[],int *deiktis,int *vrethike)
 382: {
 383:     int i;
 384:     i=0;
 385:     *vrethike=0;
 386:     *deiktis=-1;
 387:     for(i=1;i<=megethos;i++)
 388:     {
 389:         if(kleidi==pinakas[i])
 390:         {
 391:             *deiktis=i;
 392:             *vrethike=1;
 393:             break;
 394:         }
 395:     }
 396: }
 397:  
 398: /////////////////////////////////////////////////////////
 399:  
 400: 
 401:  
 402: 3.pages.c
 403:     Αρχείο το οποίο περιέχει την υλοποίηση της συνάρτησης main(), απαραίτητης 
 404:     για την εκτέλεση του προγράμματος.
 405: /*** Αρχειο pages.c - Paging Program. ***/
 406: /* ----------------------- *
 407:  * Κωνσταντίνος Χαλβαντζής *
 408:  * ----------------------- *
 409:  * Α.Μ. : 018200100093 *
 410:  ********************************************/
 411: #include <stdio.h>
 412: #include <stdlib.h>
 413: #include <string.h>
 414: #include "pages.h"
 415:  
 416: 
 417: int main(int argc,char *argv[])
 418: {
 419:     
 420:     int i;
 421:     M=0; //Main Memory.
 422:     CM=0; //Cache Memory.
 423:  
 424:     if( argc == 2 && strcmp( argv[1], "-belady" ) == 0 )
 425:     {
 426:         belady();  //Παραδοξο του Belady και γραφικες παραστασεις page faults / page frames.
 427:     }
 428:     else
 429:     {
 430:         if ((argc<7) || (argc>7) || (strcmp( argv[1], "-f" ) != 0) || (strcmp( argv[3], "-pf" ) != 0) || (strcmp( argv[5], "-s" ) != 0))
 431:         {
 432:             //Σωστη συνταξη εντολων
 433:             printf("\npages -f <RefStringFile_Path> -pf <PAGEFRAMES_NUMBER> -s <SELECT_PAGESREPLACEMENT>");
 434:             printf("\npages -belady 'GIA PARADEIGMA TOY BELADY' ");
 435:             printf("\npages -f <RefStringFile_Path> -pf <PAGEFRAMES_NUMBER> -s <SELECT_PAGESREPLACEMENT> -cm <CACHE FRAMES>\n");
 436:             exit(-1);
 437:         }
 438:     }
 439:  
 440:     if ((argc==9) && (strcmp( argv[1], "-f" ) == 0) && (strcmp( argv[3], "-pf" ) == 0) && (strcmp( argv[5], "-s" ) == 0) && (strcmp( argv[7], "-cm" ) == 0))
 441:     {
 442: 
 443:         //Διαβαζουμε απο την γραμμη εντολων τον αριθμο των cache frames.
 444:         sscanf(argv[8], "%d", &cf);
 445:         //Δεσμευουμε μνημη για τον πινακα της Cache Memory.
 446:         CM=malloc(cf*sizeof(int));
 447:     
 448:     }
 449:     //Διαβαζουμε απο την γραμμη εντολων τον αριθμο των page frames.
 450:     sscanf(argv[4], "%d", &pf);
 451:     //Δεσμευουμε μνημη για τον πινακα της Main Memory.
 452:     M=malloc((pf+1)*sizeof(int));
 453:     
 454:     //Ανοιγουμε το αρχειο που περιεχει το reference string για διαβασμα.
 455:     file_ptr=fopen(argv[2],"r");
 456: 
 457:     if(file_ptr==NULL)
 458:     {
 459:             printf("keno arxeio");
 460:             exit(0);
 461:     }
 462:     else
 463:     {    
 464:         i=1;
 465:         while(!feof(file_ptr))
 466:         {
 467:             {
 468:                 fscanf(file_ptr,"%d",&RS[i]); //Τοποθετουμε τις αναφορες του reference string 
 469:                 i++;                          //του αρχειου στον πινακα RS.
 470:             }
 471:         }
 472:     }
 473:  
 474:     MAX=i-2;  //Θετουμε το πραγματικο μεγεθος του πινακα RS.
 475:     fclose(file_ptr); //Κλεινουμε το αρχειο.
 476: 
 477:     selection(argv[6]); //Επιλεγουμε την μεθοδο αντικαταστασης σελιδων.
 478: 
 479: }
 480: 
 481:  
 482: 4.belady.c
 483:     Αρχείο το οποίο περιέχει τον ορισμό-υλοποίηση της συνάρτησης belady() που 
 484:     χρησιμοποιείται για την παρουσίαση του παράδοξου του belady καθώς και των
 485:     γραφικών παραστάσεων των page faults ως προς τα page frames για κάθε 
 486:     αλγόριθμο ξεχωριστά.
 487: /*** Αρχειο belady.c - BELADY,GRAPHICAL FUNCTIONS. ***/
 488: /* ----------------------- *
 489:  * Κωνσταντίνος Χαλβαντζής *
 490:  * ----------------------- *
 491:  * Α.Μ. : 018200100093 *
 492:  *****************************************************/
 493:  
 494: #include <stdio.h>
 495: #include <stdlib.h>
 496: #include "pages.h"
 497:  
 498: /*Παρουσιαση ενος παραδειγματος που παρουσιαζει το παραδοξο του Belady και οι γραφικες παραστασεις των
 499: page faults ανα page frame για ολους τους αλγοριθμους για το συγκεκριμενο παραδειγμα.*/
 500: 
 501: void belady()
 502: {
 503:     int epilogi;
 504:     printf("ESTO TO PARAKATO PARADEIGMA STOIXEIOSEIRAS POY DINEI TO PARADOKSO\n");
 505:     printf("TOY BELADY :\n");
 506:     printf("1 2 3 4 5 6 7 1 2 8 1 2 3 4 5 6 7 8 1 2 3 4 5\n");
 507:     printf("MPOROYME NA GENIKEYSOYME THN METHODO EYRESHS MIAS TETOIAS\n");
 508:     printf("STOIXEIOSEIRAS OTAN O ARITHMOS TON PAGE FRAMES AFKSANEI SE N\n");
 509:     printf("DHMIOYRGOYME MIA STOIXEIOSEIRA APO ANAFORES 1..N AKOLOYTHOYMENH APO\n");
 510:     printf("1 2 N+1 KAI META APO 1..N+1\n");
 511:     printf("GIA THN GRAFIKH APEIKONISH TON ALGORITHMON\n");
 512: a:    printf("EPEILEKSTE ENAN ALGORITHMO APO TOUS PARAKATO (DOSTE 0 GIA EKSODO)\n");
 513:     printf("1.FIFO\n");
 514:     printf("2.RANDOM\n");
 515:     printf("3.LRU\n");
 516:     printf("4.CLOCK\n");
 517:     scanf("%d",&epilogi);
 518: 
 519:     switch(epilogi)
 520:     {
 521:     case 0:
 522:         exit(0);
 523:     case 1:
 524:         printf("------------------FIFO------------------\n");
 525:     printf("Pages Faults\n\n");
 526:         printf("25| .. \n");
 527:         printf(" | ..... . \n");
 528:         printf("20| .. . \n");
 529:         printf(" | . \n");
 530:         printf("15| . \n");
 531:         printf(" | . \n"); 
 532:         printf("10| . \n");
 533:         printf(" | ................ \n");
 534:         printf("5 | \n");
 535:         printf(" | \n");
 536:         printf("0---------------------------------------\n");
 537:         printf(" 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Pages Frames\n");
 538: 
 539:  
 540:         break;
 541:     case 2:
 542:         printf("------------------RANDOM------------------\n");
 543:     printf("Pages Faults\n\n");
 544:         printf("25| .. \n");
 545:         printf(" | ... \n");
 546:         printf("20| . \n");
 547:         printf(" | . \n");
 548:         printf("15| .. \n");
 549:         printf(" | . \n"); 
 550:         printf("10| . \n");
 551:         printf(" | ................... \n");
 552:         printf("5 | \n");
 553:         printf(" | \n");
 554:         printf("0---------------------------------------\n");
 555:         printf(" 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Pages Frames\n");
 556: 
 557:         break;
 558:     case 3:
 559:         printf("------------------LRU------------------\n");
 560:     printf("Pages Faults\n\n");
 561:         printf("25| .. \n");
 562:         printf(" | ...... \n");
 563:         printf("20| . \n");
 564:         printf(" | .. \n");
 565:         printf("15| . \n");
 566:         printf(" | . \n");
 567:         printf("10| . \n");
 568:         printf(" | ................... \n");
 569:         printf("5 | \n");
 570:         printf(" | \n");
 571:         printf("0---------------------------------------\n");
 572:         printf(" 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Pages Frames\n");
 573:  
 574:         break;
 575:     case 4:
 576:         printf("------------------CLOCK------------------\n");
 577:     printf("Pages Faults\n\n");
 578:         printf("25| .. \n");
 579:         printf(" | ..... . \n");
 580:         printf("20| .. . \n");
 581:         printf(" | . \n");
 582:         printf("15| . \n");
 583:         printf(" | . \n"); 
 584:         printf("10| . \n");
 585:         printf(" | ................ \n");
 586:         printf("5 | \n");
 587:         printf(" | \n");
 588:         printf("0---------------------------------------\n");
 589:         printf(" 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Pages Frames\n");
 590: 
 591:  
 592:         break;
 593:     default:
 594:         printf("Epileksate ektos pediou!Dokimaste ksana");
 595:         goto a;
 596:         break;
 597:     }
 598:     goto a;
 599:  
 600: 
 601: }
 602: 5.cache.c
 603:     Αρχειο το οποιο περιεχει τις υλοποιησεις των συναρτησεων που 
 604:         χρησιμοποιουνται για τον υπολογισμο του χρονου εκτελεσης των στοιχειοσειρων
 605:     τοσο με την χρηση της cache memory οσο και χωρις αυτη.Τα αποτελεσματα των
 606:     υπολογισμων αποθηκευονται στα αρχεια time στο current directory.
 607: /*Αρχειο cache.c - Cache Memory Συναρτησεις.*/
 608: /* ----------------------- *
 609:  * Κωνσταντίνος Χαλβαντζής *
 610:  * ----------------------- *
 611:  * Α.Μ. : 018200100093 *
 612:  ********************************************/
 613:  
 614: #include <stdio.h>
 615: #include <stdlib.h>
 616: #include "pages.h"
 617:  
 618: //Αποθηκευει την επομενη θεση του πινακα της μνημης.
 619: int epomthesi=1;
 620: 
 621: /////////////////////////////////////////////////////////////////////////////////////////
 622: 
 623: /*Ο αλγόριθμος LRU βασίζεται στην παρατήρηση ότι οι σελίδες που χρησιμοποιούνται 
 624: πολύ στις τελευταίες εντολές θα χρησιμοποιηθούν πιθανότατα πολύ και στις επόμενες. 
 625: Αντίστροφα σελίδες που δεν έχουν χρησιμοποιηθεί για πολύ καιρό πιθανότατα θα 
 626: παραμείνουν στο μέλλον αχρησιμοποίητες για μεγάλο χρονικό διάστημα. Όταν προκύπτει 
 627: σφάλμα σελίδας αφαιρείται η σελίδα που δεν έχει χρησιμοποιηθεί για το μεγαλύτερο 
 628: χρονικό διάστημα. Για αυτό και η στρατηγική αυτή ονομάζεται σελιδοποίηση LRU (Least Recently Used) 
 629: και προτείνει την αφαίρεση της σελίδας που χρησιμοποιήθηκε λιγότερο πρόσφατα. Εδώ χρησιμοποιούμε
 630: την μεθοδο LRU στην cache memory για τον υπολογισμό του χρόνου.*/
 631:  
 632: void lrucm(int *M,int *CM,int *RS,int MAX,char *select)
 633: {
 634:     char xar[10];
 635:     int i,k,r;
 636:     int deiktis=0;
 637:     int vrethikem=0;
 638:     int vrethikec=0;
 639:     int j=1;
 640:     i=1;
 641:     timem=timec=timeall=0;
 642:     *xar=*select;
 643:  
 644:     while(i<=MAX)
 645:     {
 646:         anazitisi(RS[i],cf,CM,&deiktis,&vrethikec);
 647:         if(vrethikec==1)
 648:         {
 649:             timec+=(0.001*Z);
 650:             r=deiktis;
 651:             for(k=r;k<cf;k++)
 652:             {
 653:                 CM[k]=CM[k+1];
 654:             }
 655: CM
[cf][/cf]


=RS[i];
 656:         }
 657:         if(vrethikec==0)
 658:         {
 659:             timec+=(0.001*Z);
 660:             for(k=1;k
 661:             {
 662:                 CM[k]=CM[k+1];
 663:             }
 664: CM
[cf][/cf]
=RS[i];
 665:             
 666:             switch (*select)
 667:             {
 668:                 case '1':
 669:                     timem+=random1m(M,RS[i],MAX);
 670:                     break;
 671:                 case '2':
 672:                     timem+=fifom(M,RS[i],MAX);
 673:                     break;
 674:                 case '3':
 675:                     timem+=lrum(M,RS[i],MAX);
 676:                     break;
 677:                 case '4':
 678:                     timem+=clockm(M,RS[i],MAX);
 679:                     break;
 680:                 default:
 681:                     printf("Lathos Epilogi(Epilekste anamesa se 1-4)");
 682:                     exit(0);
 683:             }
 684:         }
 685:         i++;
 686:     }
 687:     timeall=timem+timec;
 688:     timefilecm(xar,timeall,1);
 689: }
 690: 
 691: //////////////////////////////////////////////////////////////////////////////
 692: 
 693: /*Αλγοριθμος τυχαιας αντικαταστασης σελιδων.Διαλέγεται μια τυχαία σελίδα 
 694: από την μνήμη για να πραγματοποιηθεί η αντικατάσταση της από την νέα σελίδα.
 695: Διαβαζονται οι αναφορες του reference string απο τον πινακα RS και τοποθετουνται 
 696: στα page frames της Main memory με τυχαια επιλογη. */
 697:  
 698: float random1m(int *M,int RS,int MAX)
 699: {
 700:     int r;
 701:     int deiktis=0;
 702:     int vrethike=0;
 703:     float time=0;
 704: 
 705:     anazitisi(RS,pf,M,&deiktis,&vrethike);
 706:     if(vrethike==0)
 707:     {
 708: 
 709:         time=Z;
 710:         r=rand()%pf;   //Τυχαια επιλογη του δεικτη r.
 711:         r=r+1;
 712:         if(r!=0)
 713:         {
 714:             M[r]=RS;        //Τυχαια αντικατασταση σελιδας στο page frame ετσι οπως επιλεγεται απο τον δεικτη r.
 715:         }
 716:     }
 717:     if(vrethike==1)
 718:     {
 719:         time=Z;
 720:     }
 721:     return (time);
 722: }
 723:  
 724: 
 725:  
 726: ////////////////////////////////////////////////////////////////
 727:  
 728: /*Στον αλγόριθμο αντικατάστασης σελίδας FIFO το λειτουργικό σύστημα διατηρεί 
 729: μια λίστα με τις σελίδες που βρίσκονται στην μνήμη. Στην αρχή της λίστας βρίσκεται 
 730: η παλαιότερη σελίδα και στην ουρά της η τελευταία που εμφανίστηκε. Όταν συμβαίνει 
 731: σφάλμα σελίδας η σελίδα που βρίσκεται στην αρχή της λίστας αφαιρείται και η νέα σελίδα 
 732: προστίθεται στην ουρά της λίστας.*/
 733:  
 734: float fifom(int *M,int RS,int MAX)
 735: {
 736:     int deiktis=0;
 737:     int vrethike=0;
 738:     float time=0;
 739:  
 740:     anazitisi(RS,pf,M,&deiktis,&vrethike);
 741:     if(vrethike==0)
 742:     {
 743:         time=Z;
 744:         if (epomthesi<=pf)
 745:         {
 746:             M[epomthesi]=RS;
 747:             epomthesi++;
 748:         }
 749:         if(epomthesi>pf)
 750:         {
 751:             epomthesi=1;
 752:         }
 753:     }
 754:     if(vrethike==1)
 755:     {
 756:             time=Z;
 757:     }
 758: 
 759:     return (time);
 760: }
 761:  
 762: 
 763:  
 764: //////////////////////////////////////////////////////////////
 765:  
 766: /*Ο αλγόριθμος LRU βασίζεται στην παρατήρηση ότι οι σελίδες που χρησιμοποιούνται 
 767: πολύ στις τελευταίες εντολές θα χρησιμοποιηθούν πιθανότατα πολύ και στις επόμενες. 
 768: Αντίστροφα σελίδες που δεν έχουν χρησιμοποιηθεί για πολύ καιρό πιθανότατα θα 
 769: παραμείνουν στο μέλλον αχρησιμοποίητες για μεγάλο χρονικό διάστημα. Όταν προκύπτει 
 770: σφάλμα σελίδας αφαιρείται η σελίδα που δεν έχει χρησιμοποιηθεί για το μεγαλύτερο 
 771: χρονικό διάστημα. Για αυτό και η στρατηγική αυτή ονομάζεται σελιδοποίηση LRU (Least Recently Used) 
 772: και προτείνει την αφαίρεση της σελίδας που χρησιμοποιήθηκε λιγότερο πρόσφατα. */
 773:  
 774: float lrum(int *M,int RS,int MAX)
 775: {
 776:     int k,r;
 777:     int deiktis=0;
 778:     int vrethike=0;
 779:     int j=1;
 780:     float time=0;
 781:     
 782:     anazitisi(RS,pf,M,&deiktis,&vrethike);
 783:     if(vrethike==1)
 784:     {
 785:         time=Z;
 786:         r=deiktis;
 787:         for(k=r;k<pf;k++)
 788:         {
 789:             M[k]=M[k+1];
 790:         }
 791:         M[pf]=RS;
 792:     }
 793:     if(vrethike==0)
 794:     {
 795:         time=Z;
 796:         for(k=1;k<pf;k++)
 797:         {
 798:             M[k]=M[k+1];
 799:         }
 800:         M[pf]=RS;
 801:     }    
 802:     return(time);
 803: }
 804: 
 805: /////////////////////////////////////////////////////////////////
 806: 
 807: /*Στον αλγόριθμο clock διατηρούνται όλες οι σελίδες σε μια κυκλική λίστα η 
 808: οποία έχει μορφή ρολογιού. Ένας δείκτης δείχνει στην παλαιότερη σελίδα. 
 809: Όταν προκύψει σφάλμα σελίδας ελέγχεται η σελίδα στην οποία δείχνει ο δείκτης. 
 810: Αν το bit A είναι 0, η σελίδα αφαιρείται και η νέα σελίδα εισάγεται στην θέση 
 811: της μέσα στο ρόλοι, ενώ ο δείκτης προχωρεί κατά μια θέση. Αν το bit Α είναι 1, 
 812: τότε γίνεται 0 και ο δείκτης προχωρεί στην επόμενη σελίδα. Αυτή η διαδικασία 
 813: επαναλαμβάνεται μέχρι να βρεθεί κάποια σελίδα που να έχει την τιμή 0 στο bit Α της.*/
 814: 
 815: float clockm(int *M,int RS,int MAX)
 816: {
 817:     int deiktis=0;
 818:     int vrethike=0;
 819:     int j=1;
 820:     int *rbit;
 821:     float time=0;
 822:     rbit=malloc(pf*sizeof(int));
 823:  
 824:     anazitisi(RS,pf,M,&deiktis,&vrethike);
 825:     if(vrethike==1)
 826:     {
 827:         time=Z;
 828:         rbit[deiktis]=1;
 829:     }
 830:     if(vrethike==0)
 831:     {
 832:         time=Z;
 833:         for(j=epomthesi;j<=pf;j++)
 834:         {
 835:             if((rbit[j]==0) || (M[j]<=0))
 836:             {
 837:                 M[j]=RS;
 838:                 rbit[j]=1;
 839:                 epomthesi=j+1;      
 840:                 if(epomthesi>pf)
 841:                 {
 842:                     epomthesi=1;
 843:                 }
 844:                 break;
 845:             }
 846:             else
 847:             {
 848:                 if(rbit[j]==1)
 849:                 {
 850:                     rbit[j]=0;
 851:                 }    
 852:             }
 853:             if(j==pf)
 854:             {
 855:                 j=0;
 856:                 break;
 857:             }
 858:         }
 859:     }
 860:     return(time);
 861: }
 862: 
 863: ///////////////////////////////////////////////////////////////////////////
 864: 
 865: /*Η παρακατω συναρτηση δημιουργει τα αρχεια στα οποια αποθηκευονται τα αποτελεσματα για
 866: τον χρονο τοσο με cache memory οσο και χωρις.*/
 867:  
 868: void timefilecm(char *selection,float time,int cache)
 869: {
 870:     FILE *Fileptr;
 871:     switch (*selection)
 872:     {
 873:     case '1':
 874:         Fileptr=fopen("timeRAND","a");
 875:         fprintf(Fileptr,"**************************************\n");
 876:         fprintf(Fileptr,"ME Z = %d\n",Z);
 877:         if(cache==0)
 878:         {
 879:             fprintf(Fileptr,"==================================\n");
 880:             fprintf(Fileptr,"XORIS CACHE MEMORY\n");
 881:         }
 882:         if(cache==1)
 883:         {
 884:             fprintf(Fileptr,"==================================\n");
 885:             fprintf(Fileptr,"ME CACHE MEMORY\n");
 886:         }
 887:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ ΤΥΧΑΙΑΣ ΕΠΙΛΟΓΗΣ-random1\n");
 888:         fprintf(Fileptr,"==================================\n");
 889:         break;
 890:     case '2':
 891:         Fileptr=fopen("timeFIFO","a");
 892:         fprintf(Fileptr,"**************************************\n");
 893:         fprintf(Fileptr,"ME Z = %d\n",Z);
 894:         if(cache==0)
 895:         {
 896:             fprintf(Fileptr,"==================================\n");
 897:             fprintf(Fileptr,"XORIS CACHE MEMORY\n");
 898:         }
 899:         if(cache==1)
 900:         {
 901:             fprintf(Fileptr,"==================================\n");
 902:             fprintf(Fileptr,"ME CACHE MEMORY\n");
 903:         }
 904:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ FIFO\n");
 905:         fprintf(Fileptr,"===============\n");
 906:         break;
 907:     case '3':
 908:         Fileptr=fopen("timeLRU","a");
 909:         fprintf(Fileptr,"**************************************\n");
 910:         fprintf(Fileptr,"ME Z = %d\n",Z);
 911:         if(cache==0)
 912:         {
 913:             fprintf(Fileptr,"==================================\n");
 914:             fprintf(Fileptr,"XORIS CACHE MEMORY\n");
 915:         }
 916:         if(cache==1)
 917:         {
 918:             fprintf(Fileptr,"==================================\n");
 919:             fprintf(Fileptr,"ME CACHE MEMORY\n");
 920:         }
 921:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ LRU\n");
 922:         fprintf(Fileptr,"==============\n");
 923:         break;
 924:     case '4':
 925:         Fileptr=fopen("timeCLOCK","a");
 926:         fprintf(Fileptr,"**************************************\n");
 927:         fprintf(Fileptr,"ME Z = %d\n",Z);
 928:         if(cache==0)
 929:         {
 930:             fprintf(Fileptr,"==================================\n");
 931:             fprintf(Fileptr,"XORIS CACHE MEMORY\n");
 932:         }
 933:         if(cache==1)
 934:         {
 935:             fprintf(Fileptr,"==================================\n");
 936:             fprintf(Fileptr,"ME CACHE MEMORY\n");
 937:         }
 938:         fprintf(Fileptr,"ΑΛΓΟΡΙΘΜΟΣ CLOCK\n");
 939:         fprintf(Fileptr,"================\n");
 940:         break;
 941:     default:
 942:         break;
 943:     }
 944:     fprintf(Fileptr,"Time is %lf\n",time);
 945:     fclose(Fileptr);
 946: }
 947:  
 948: ///////////////////////////////////////////////////////////////////
 949:  
 950: /*Η παρακατω συναρτηση υπολογιζει τον χρονο χωρις την χρηση της cache memory.*/
 951:  
 952: void nocachetime(int *M,int *RS,int MAX,char *select)
 953: {
 954:     char xar[10];
 955:     int    i=1;
 956:     *xar=*select;
 957:  
 958:     while(i<=MAX)
 959:     {
 960:         switch (*select)
 961:         {
 962:             case '1':
 963:                 timem+=random1m(M,RS[i],MAX);
 964:                 break;
 965:             case '2':
 966:                 timem+=fifom(M,RS[i],MAX);
 967:                 break;
 968:             case '3':
 969:                 timem+=lrum(M,RS[i],MAX);
 970:                 break;
 971:             case '4':
 972:                 timem+=clockm(M,RS[i],MAX);
 973:                 break;
 974:             default:
 975:                 printf("Lathos Epilogi(Epilekste anamesa se 1-4)");
 976:                 exit(0);
 977:         }
 978:         i++;
 979:     }
 980:     timefilecm(xar,timem,0);
 981: }

------------------------------------------------------------------------------------------

Για την εκτέλεση του προγράμματος αφού δώσετε την εντολή make στο current directory των παραπάνω αρχείων για να γίνει αυτόματα το compile στη συνεχεία δώστε :

Για την εκτέλεση του προσομοιωτή ιδεατής μνήμης δώστε την παρακάτω εντολή:

pages -f <RefStringFile_Path> -pf <PAGEFRAMES_NUMBER> -s <SELECT_PAGES_REPLACEMENT_METHOD>

Για την παρουσίαση του παράδοξου του Belady και των γραφικών παραστάσεων των page

faults ως προς τα page frames για κάθε αλγόριθμο ξεχωριστά δώστε την παρακάτω εντολή:

pages -belady

Για τον υπολογισμο του χρονου εκτελεσης των στοιχειοσειρων με την χρηση της cache memory αλλα και χωρις την χρηση αυτης δωστε την παρακατω εντολη:

pages -f <RefStringFile_Path> -pf <PAGEFRAMES_NUMBER> -s <SELECT_PAGES_REPLACEMENT_METHOD> -cm <CacheFrames_Number>

Τα αποτελεσματα των υπολογισμων αποθηκευονται στα αρχεια time στο current directory.

RESULTS

clip_image004

One Comment

Comments are closed.

yeezy boost 350 ua yeezytrainer yeezy boost 350 ua yeezytrainer yeezytrainer yeezy boost 350 ua yeezy boost 350 ua yeezy shoes yeezy shoes yeezy boost online

yeezy 350 boost for sale yeezy boost online yeezy shoes yeezy 350 boost for sale yeezy boost online yeezy shoes yeezy 350 boost for sale yeezy boost online yeezy shoes yeezy 350 boost for sale yeezy boost online yeezy shoes