Skip to content

Commit 2d17e01

Browse files
tusharnankanitusharnankani
committed
✨ feat: add LOOK, CLOOK algorithms
1 parent 771d907 commit 2d17e01

File tree

1 file changed

+296
-7
lines changed

1 file changed

+296
-7
lines changed

‎DiskSchedulingPolicy.java

+296-7
Original file line numberDiff line numberDiff line change
@@ -35,8 +35,11 @@ void processInput() {
3535
System.out.println("[1] FCFS (First Come First Serve)");
3636
System.out.println("[2] SSTF (Shortest Seek Time First)");
3737
System.out.println("[3] SCAN ");
38-
System.out.println("[4] Exit ");
39-
System.out.print("Enter your choice? [1-4]: ");
38+
System.out.println("[4] C-SCAN ");
39+
System.out.println("[5] LOOK ");
40+
System.out.println("[6] C-LOOK ");
41+
System.out.println("[7] Exit ");
42+
System.out.print("Enter your choice? [1-7]: ");
4043
switch(s.nextInt()) {
4144
case 1: {
4245
FCFS();
@@ -51,14 +54,30 @@ void processInput() {
5154
break;
5255
}
5356
case 4: {
57+
CSCAN();
58+
break;
59+
}
60+
case 5: {
61+
LOOK();
62+
break;
63+
}
64+
case 6: {
65+
CLOOK();
66+
break;
67+
}
68+
case 7: {
5469
return;
5570
}
5671
default:
57-
System.out.println("Wrong Choice, Please enter a number between 1 and 4. ");
72+
System.out.println("Wrong Choice, Please enter a number between 1 and 5. ");
5873
}
5974
}
6075
}
6176

77+
void printAverageSeekTime(int totalHeadMovement, int totalLength) {
78+
System.out.println("\n\n\tAverage Seek Time: " + (totalHeadMovement) + " / " + (totalLength) + " = " + ((double)totalHeadMovement / (double)totalLength));
79+
}
80+
6281
void FCFS() {
6382
int[] orderOfProcessing = new int[requestQueue.length];
6483
int totalHeadMovement = 0;
@@ -88,6 +107,7 @@ void FCFS() {
88107
for(int i = 1; i < orderOfProcessing.length; ++i) {
89108
System.out.print( " -> " + orderOfProcessing[i]);
90109
}
110+
printAverageSeekTime(totalHeadMovement, requestQueue.length);
91111
System.out.println();
92112
}
93113

@@ -136,6 +156,7 @@ void SSTF() {
136156
for(int i = 1; i < orderOfProcessing.length; ++i) {
137157
System.out.print( " -> " + orderOfProcessing[i]);
138158
}
159+
printAverageSeekTime(totalHeadMovement, requestQueue.length);
139160
System.out.println();
140161
}
141162

@@ -231,21 +252,289 @@ void SCAN() {
231252
for(int i = 1; i < orderOfProcessing.length; ++i) {
232253
System.out.print( " -> " + orderOfProcessing[i]);
233254
}
255+
printAverageSeekTime(totalHeadMovement, requestQueue.length);
234256
System.out.println();
235257
}
236258

237259
void CSCAN() {
260+
// "requestQueue.length + 2" since, both the extra ends will be added to the queue;
261+
int[] orderOfProcessing = new int[requestQueue.length + 2];
262+
int totalHeadMovement = 0;
263+
int currentHead = globalCurrentHead;
264+
265+
ArrayList<Integer> firstHalf = new ArrayList<Integer>();
266+
ArrayList<Integer> secondHalf = new ArrayList<Integer>();
267+
268+
for(int i = 0; i < requestQueue.length; ++i) {
269+
if(currentHead > requestQueue[i])
270+
firstHalf.add(requestQueue[i]);
271+
else
272+
secondHalf.add(requestQueue[i]);
273+
}
274+
Collections.sort(firstHalf);
275+
Collections.sort(secondHalf);
276+
System.out.print(firstHalf);
277+
System.out.println(secondHalf);
278+
279+
System.out.print("\nTraverse to the inner track or the outer track? \n [0] Inner Track\n [1] Outer Track \n Your Choice? ");
280+
int outer = s.nextInt();
281+
282+
System.out.println();
283+
System.out.println("\t\t+----------------------------------------+");
284+
System.out.println("\t\t|Output for C-SCAN Disk Scheduling Policy|");
285+
System.out.println("\t\t+----------------------------------------+");
286+
System.out.println("\n\tHead currently at: " + currentHead);
287+
288+
System.out.println("\n Iteration \t Current Head \t Disk Movement \t Total Disk Movement");
289+
System.out.println("------------------------------------------------------------------------");
290+
291+
int j = 0;
292+
// Inner Track First
293+
if(outer == 0) {
294+
for(int i = firstHalf.size() - 1; i >= 0; --i) {
295+
296+
int currentDiskMovement = Math.abs(currentHead - firstHalf.get(i));
297+
totalHeadMovement += currentDiskMovement;
298+
orderOfProcessing[j] = firstHalf.get(i);
299+
currentHead = firstHalf.get(i);
300+
301+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
302+
}
303+
304+
// going to 0;
305+
totalHeadMovement += (currentHead - 0);
306+
orderOfProcessing[j] = 0;
307+
System.out.println( "\t" + (++j) +"\t\t" + 0 + "\t\t" + (currentHead - 0) + "\t\t" + totalHeadMovement);
308+
currentHead = 0;
238309

239-
}
310+
// going to 199;
311+
totalHeadMovement += Math.abs(currentHead - 199);
312+
orderOfProcessing[j] = 199;
313+
System.out.println( "\t" + (++j) +"\t\t" + 199 + "\t\t" + 199 + "\t\t" + totalHeadMovement);
314+
currentHead = 199;
315+
316+
for(int i = secondHalf.size() - 1; i >= 0; --i) {
317+
int currentDiskMovement = Math.abs(currentHead - secondHalf.get(i));
318+
totalHeadMovement += currentDiskMovement;
319+
orderOfProcessing[j] = secondHalf.get(i);
320+
currentHead = secondHalf.get(i);
321+
322+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
323+
}
324+
}
240325

326+
// Outer Track First;
327+
else {
328+
for(int i = 0; i < secondHalf.size(); i++) {
329+
int currentDiskMovement = Math.abs(currentHead - secondHalf.get(i));
330+
totalHeadMovement += currentDiskMovement;
331+
orderOfProcessing[j] = secondHalf.get(i);
332+
currentHead = secondHalf.get(i);
333+
334+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
335+
}
336+
337+
// going to 199;
338+
totalHeadMovement += Math.abs(currentHead - 199);
339+
orderOfProcessing[j] = 199;
340+
System.out.println( "\t" + (++j) +"\t\t" + 199 + "\t\t" + Math.abs(currentHead - 199) + "\t\t" + totalHeadMovement);
341+
currentHead = 199;
342+
343+
// going to 0;
344+
totalHeadMovement += Math.abs(currentHead - 0);
345+
orderOfProcessing[j] = 0;
346+
System.out.println( "\t" + (++j) +"\t\t" + 0 + "\t\t" + 199 + "\t\t" + totalHeadMovement);
347+
currentHead = 0;
348+
349+
for(int i = 0; i < firstHalf.size(); i++) {
350+
int currentDiskMovement = Math.abs(currentHead - firstHalf.get(i));
351+
totalHeadMovement += currentDiskMovement;
352+
orderOfProcessing[j] = firstHalf.get(i);
353+
currentHead = firstHalf.get(i);
354+
355+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
356+
}
357+
}
358+
System.out.println("------------------------------------------------------------------------");
359+
360+
System.out.println("\n\tTotal Head Movement: " + totalHeadMovement);
361+
System.out.print("\n\tOrder of Processing: " + (orderOfProcessing[0]));
362+
for(int i = 1; i < orderOfProcessing.length; ++i) {
363+
System.out.print( " -> " + orderOfProcessing[i]);
364+
}
365+
printAverageSeekTime(totalHeadMovement, requestQueue.length);
366+
System.out.println();
367+
}
368+
241369
void LOOK() {
242-
370+
// "requestQueue.length" since, no extra ends will be added to the queue;
371+
int[] orderOfProcessing = new int[requestQueue.length];
372+
int totalHeadMovement = 0;
373+
int currentHead = globalCurrentHead;
374+
375+
ArrayList<Integer> firstHalf = new ArrayList<Integer>();
376+
ArrayList<Integer> secondHalf = new ArrayList<Integer>();
377+
378+
for(int i = 0; i < requestQueue.length; ++i) {
379+
if(currentHead > requestQueue[i])
380+
firstHalf.add(requestQueue[i]);
381+
else
382+
secondHalf.add(requestQueue[i]);
383+
}
384+
Collections.sort(firstHalf);
385+
Collections.sort(secondHalf);
386+
System.out.print(firstHalf);
387+
System.out.println(secondHalf);
388+
389+
System.out.print("\nTraverse to the inner track or the outer track? \n [0] Inner Track\n [1] Outer Track \n Your Choice? ");
390+
int outer = s.nextInt();
391+
392+
System.out.println();
393+
System.out.println("\t\t+--------------------------------------+");
394+
System.out.println("\t\t|Output for LOOK Disk Scheduling Policy|");
395+
System.out.println("\t\t+--------------------------------------+");
396+
System.out.println("\n\tHead currently at: " + currentHead);
397+
398+
System.out.println("\n Iteration \t Current Head \t Disk Movement \t Total Disk Movement");
399+
System.out.println("------------------------------------------------------------------------");
400+
401+
int j = 0;
402+
// inner track first
403+
if(outer == 0) {
404+
for(int i = firstHalf.size() - 1; i >= 0; --i) {
405+
406+
int currentDiskMovement = Math.abs(currentHead - firstHalf.get(i));
407+
totalHeadMovement += currentDiskMovement;
408+
orderOfProcessing[j] = firstHalf.get(i);
409+
currentHead = firstHalf.get(i);
410+
411+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
412+
}
413+
414+
for(int i = 0; i < secondHalf.size(); i++) {
415+
int currentDiskMovement = Math.abs(currentHead - secondHalf.get(i));
416+
totalHeadMovement += currentDiskMovement;
417+
orderOfProcessing[j] = secondHalf.get(i);
418+
currentHead = secondHalf.get(i);
419+
420+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
421+
}
422+
}
423+
else {
424+
for(int i = 0; i < secondHalf.size(); i++) {
425+
int currentDiskMovement = Math.abs(currentHead - secondHalf.get(i));
426+
totalHeadMovement += currentDiskMovement;
427+
orderOfProcessing[j] = secondHalf.get(i);
428+
currentHead = secondHalf.get(i);
429+
430+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
431+
}
432+
433+
for(int i = firstHalf.size() - 1; i >= 0; --i) {
434+
int currentDiskMovement = Math.abs(currentHead - firstHalf.get(i));
435+
totalHeadMovement += currentDiskMovement;
436+
orderOfProcessing[j] = firstHalf.get(i);
437+
currentHead = firstHalf.get(i);
438+
439+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
440+
}
441+
}
442+
System.out.println("------------------------------------------------------------------------");
443+
444+
System.out.println("\n\tTotal Head Movement: " + totalHeadMovement);
445+
System.out.print("\n\tOrder of Processing: " + (orderOfProcessing[0]));
446+
for(int i = 1; i < orderOfProcessing.length; ++i) {
447+
System.out.print( " -> " + orderOfProcessing[i]);
448+
}
449+
printAverageSeekTime(totalHeadMovement, requestQueue.length);
450+
System.out.println();
243451
}
244-
452+
245453
void CLOOK() {
454+
// "requestQueue.length" since, no extra ends will be added to the queue;
455+
int[] orderOfProcessing = new int[requestQueue.length];
456+
int totalHeadMovement = 0;
457+
int currentHead = globalCurrentHead;
458+
459+
ArrayList<Integer> firstHalf = new ArrayList<Integer>();
460+
ArrayList<Integer> secondHalf = new ArrayList<Integer>();
461+
462+
for(int i = 0; i < requestQueue.length; ++i) {
463+
if(currentHead > requestQueue[i])
464+
firstHalf.add(requestQueue[i]);
465+
else
466+
secondHalf.add(requestQueue[i]);
467+
}
468+
Collections.sort(firstHalf);
469+
Collections.sort(secondHalf);
470+
System.out.print(firstHalf);
471+
System.out.println(secondHalf);
472+
473+
System.out.print("\nTraverse to the inner track or the outer track? \n [0] Inner Track\n [1] Outer Track \n Your Choice? ");
474+
int outer = s.nextInt();
475+
476+
System.out.println();
477+
System.out.println("\t\t+----------------------------------------+");
478+
System.out.println("\t\t|Output for C-LOOK Disk Scheduling Policy|");
479+
System.out.println("\t\t+----------------------------------------+");
480+
System.out.println("\n\tHead currently at: " + currentHead);
481+
482+
System.out.println("\n Iteration \t Current Head \t Disk Movement \t Total Disk Movement");
483+
System.out.println("------------------------------------------------------------------------");
484+
485+
int j = 0;
486+
// inner track first
487+
if(outer == 0) {
488+
for(int i = firstHalf.size() - 1; i >= 0; --i) {
489+
490+
int currentDiskMovement = Math.abs(currentHead - firstHalf.get(i));
491+
totalHeadMovement += currentDiskMovement;
492+
orderOfProcessing[j] = firstHalf.get(i);
493+
currentHead = firstHalf.get(i);
494+
495+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
496+
}
246497

498+
499+
for(int i = secondHalf.size() - 1; i >= 0; i--) {
500+
int currentDiskMovement = Math.abs(currentHead - secondHalf.get(i));
501+
totalHeadMovement += currentDiskMovement;
502+
orderOfProcessing[j] = secondHalf.get(i);
503+
currentHead = secondHalf.get(i);
504+
505+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
506+
}
507+
}
508+
else {
509+
for(int i = 0; i < secondHalf.size(); i++) {
510+
int currentDiskMovement = Math.abs(currentHead - secondHalf.get(i));
511+
totalHeadMovement += currentDiskMovement;
512+
orderOfProcessing[j] = secondHalf.get(i);
513+
currentHead = secondHalf.get(i);
514+
515+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
516+
}
517+
518+
for(int i = 0; i < firstHalf.size(); ++i) {
519+
int currentDiskMovement = Math.abs(currentHead - firstHalf.get(i));
520+
totalHeadMovement += currentDiskMovement;
521+
orderOfProcessing[j] = firstHalf.get(i);
522+
currentHead = firstHalf.get(i);
523+
524+
System.out.println( "\t" + (++j) +"\t\t" + currentHead + "\t\t" + currentDiskMovement + "\t\t" + totalHeadMovement);
525+
}
526+
}
527+
System.out.println("------------------------------------------------------------------------");
528+
529+
System.out.println("\n\tTotal Head Movement: " + totalHeadMovement);
530+
System.out.print("\n\tOrder of Processing: " + (orderOfProcessing[0]));
531+
for(int i = 1; i < orderOfProcessing.length; ++i) {
532+
System.out.print( " -> " + orderOfProcessing[i]);
533+
}
534+
printAverageSeekTime(totalHeadMovement, requestQueue.length);
535+
System.out.println();
247536
}
248-
537+
249538
}
250539

251540
class DiskSchedulingPolicy {

0 commit comments

Comments
 (0)