· 8 years ago · Feb 23, 2018, 11:46 PM
1// Kyle Savell & Antony Qin
2
3#include <stdio.h>
4#include <stdlib.h>
5#include <string.h>
6#include <ctype.h>
7#include <assert.h>
8
9#define SIZE 64
10#define MAXPROC 4
11#define MAXPAGE 4
12
13// Memory
14unsigned char memory[SIZE];
15
16// PID array
17int pid_array[MAXPROC];
18
19// Free list
20int free_list[MAXPROC];
21
22// Permissions
23int write_list[MAXPROC][MAXPAGE];
24
25// Existing Pages
26int page_exists[MAXPROC][MAXPAGE];
27
28// Page Location on Disk
29int on_disk[MAXPROC][MAXPAGE + 1];
30
31// Disk
32FILE *disk;
33
34// Round Robin Eviction
35int last_evict = 0;
36
37// Function Declarations
38int find_page(int addr); // Returns a corresponding page based on an address
39int find_address(int page); // Returns address of the start of a given page
40int write_mem(int start, char* value); // Writes integer into memory, start is the physical address we want to write to
41int read_mem(int start); // Reads integer from memory
42int translate_ptable(int pid, int v_addr); // Translate page table, return physical address from virtual address
43int create_ptable(int pid); // Allocates page table entry into virtual page
44int map(int pid, int v_addr, int r_value); // Maps virtual page to physical page
45int store(int pid, int v_addr, int value); // Stores value in physical memory
46int load(int pid, int v_addr); // Loads value from physical memory
47int evict(int pid); // Returns physical page that is to be evicted
48int remap(int pid, int v_page, int p_page); //Remaps virtual page if pulled from disk
49int replace_page(int pid, int v_page); // Handles page replacements
50int swap(int page, int lineNum); // Swaps page from physical memory and disk, returns lineNum page was put in disk
51int putToDisk(char page[16]); // Puts page in disk
52int getFromDisk(char (*pageHolder)[16], int lineNum); // Gets page from disk
53
54void logMem(); // DEBUGGING ONLY; DISPLAYS PHYSICAL MEMORY
55void logMem()
56{
57 for(int i = 0; i < 64; i++)
58 {
59 printf("INDEX %d IN MEMORY IS: [%c]\n", i, memory[i]);
60 }
61}
62
63// Returns a corresponding page based on an address
64int find_page(int addr)
65{
66 if(addr >= 0 && addr < 16)
67 return 0;
68 else if(addr >= 16 && addr < 32)
69 return 1;
70 else if(addr >= 32 && addr < 48)
71 return 2;
72 else if(addr >= 48 && addr < 64)
73 return 3;
74}
75
76// Returns address of the start of a given page
77int find_address(int page)
78{
79 if (page == 0)
80 {
81 return 0;
82 }
83 else if (page == 1)
84 {
85 return 16;
86 }
87 else if (page == 2)
88 {
89 return 32;
90 }
91 else
92 {
93 return 48;
94 }
95}
96
97// Writes integer into memory, start is the physical address we want to write to
98int write_mem(int start, char* value)
99{
100 int num_bytes = strlen(value);
101 int remainder = start%16;
102 if ((remainder + num_bytes) >= 15)
103 {
104 return -1; // Not enough room on the current page
105 }
106
107 int i;
108 for(i = start; i < 16 + start; i++)
109 {
110 if(value[i - start] != 0)
111 memory[i] = value[i - start];
112 else
113 break;
114 }
115
116 return (i - start); // Number of bytes written
117}
118
119// Reads integer from memory
120int read_mem(int start)
121{
122 int read_val;
123 char buffer[4];
124 for(int i = 0; i < 4; i++)
125 {
126 if(memory[start + i] != '*' && i != 3)
127 buffer[i] = memory[start + i];
128 else
129 {
130 buffer[i] = '\0';
131 break;
132 }
133 }
134 if(buffer[0] == '\0') return -1;
135 else
136 {
137 sscanf(buffer, "%d", &read_val);
138 return read_val;
139 }
140}
141
142// Translate page table, return physical address from virtual address
143// ptable format is an array {0,',',1,1,',',2} -> single digit to immediate left of , is virtual page, single digit to immediate right of , is physical page the vitual page is mapped to.
144// In example, virtual page 0 is mapped to physical page 1 & virtual page 1 is mapped to physical page 2
145int translate_ptable(int pid, int v_addr)
146{
147 int start = pid_array[pid];
148 int v_page = find_page(v_addr);
149 int offset = v_page * 16;
150 int phys_addr = -1;
151 int cur_addr = start;
152 for (int i = 0; i < 16; i++) // Only look up to end of page table virtual page
153 {
154 if (memory[cur_addr] == ',') // PTE Separator
155 {
156 if(memory[cur_addr - 1] - '0' == find_page(v_addr))
157 return find_address(memory[cur_addr + 1] - '0') + v_addr - offset;
158 }
159 cur_addr++;
160 }
161 return phys_addr; // Return physical address, -1 if address not found
162}
163
164// Allocates page table entry into virtual page
165int create_ptable(int pid)
166{
167 int been_allocated = -1;
168 for(int i = 0; i < 4; i++)
169 {
170 if (free_list[i] == -1)
171 {
172 free_list[i] = 0;
173 pid_array[pid] = find_address(i); // Put physical address into pid register
174 been_allocated = 1;
175 printf("Put page table for PID %d into physical frame %d\n", pid, i);
176 break;
177 }
178 }
179
180 if (been_allocated == -1)
181 {
182 int to_evict = evict(pid);
183 swap(to_evict, -1);
184 //replace_page(pid, -1);
185 int p_page = last_evict;
186 pid_array[pid] = find_address(p_page);
187 printf("Put page table for PID %d into physical frame %d\n", pid, p_page);
188 }
189}
190
191// Maps virtual page to physical page
192int map(int pid, int v_addr, int r_value)
193{
194 int page_table = pid_array[pid];
195 int been_allocated = -1;
196 char full_str[16] = "";
197 char buffer[10];
198 char new_entry[10];
199
200 int v_page = find_page(v_addr);
201 int p_page;
202
203 // Create page table for process if one does not exist
204 if (page_table == -1 && on_disk[pid][0] == -1)
205 {
206 create_ptable(pid);
207 }
208
209 // Check if entry already exists and update it
210 if (page_exists[pid][v_page] == 1)
211 {
212 if (write_list[pid][v_page] == r_value) {
213 printf("ERROR: virtual page %d is already mapped with rw_bit=%d\n", v_page, r_value);
214 } else {
215 printf("Updating permissions for virtual page %d (frame %d)\n", v_page, find_page(translate_ptable(pid, find_address(v_page)))); //
216 write_list[pid][v_page] = r_value;
217 }
218 }
219
220 // Create new entry
221 // memset(&buffer[0], 0, sizeof(buffer));
222 else
223 {
224 for(int i = 0; i < 4; i++)
225 {
226 if (free_list[i] == -1)
227 {
228 free_list[i] = 0;
229 write_list[pid][v_page] = r_value; // Set permissions
230 page_exists[pid][v_page] = 1; // Set existence of page
231 been_allocated = 1;
232 p_page = i;
233
234 int write_addr = pid_array[pid];
235 for(int j = 0; j < 16; j++)
236 {
237 if (memory[write_addr] == '*') // Write entry to ptable
238 {
239 sprintf(buffer, "%d", v_page);
240 strcat(full_str, buffer);
241 strcat(full_str, ",");
242 sprintf(buffer, "%d", p_page);
243 strcat(full_str, buffer);
244 write_addr += write_mem(write_addr, full_str);
245 break;
246 }
247 write_addr++;
248 }
249
250 printf("Mapped virtual address %d (page %d) into physical frame %d\n", v_addr, v_page, p_page);
251 break;
252 }
253 }
254 if (been_allocated == -1)
255 {
256 int to_evict = evict(pid);
257 swap(to_evict, -1);
258 //replace_page(pid, -1);
259 write_list[pid][v_page] = r_value; // Set permissions
260 page_exists[pid][v_page] = 1; // Set existence of page
261 been_allocated = 1;
262 p_page = last_evict;
263
264 int write_addr = pid_array[pid];
265 for(int j = 0; j < 16; j++)
266 {
267 if (memory[write_addr] == '*') // Write entry to ptable
268 {
269 sprintf(buffer, "%d", v_page);
270 strcat(full_str, buffer);
271 strcat(full_str, ",");
272 sprintf(buffer, "%d", p_page);
273 strcat(full_str, buffer);
274 write_addr += write_mem(write_addr, full_str);
275 break;
276 }
277 write_addr++;
278 }
279
280 printf("Mapped virtual address %d (page %d) into physical frame %d\n", v_addr, v_page, p_page);
281 }
282 }
283
284 return 0; // Success
285}
286
287// Stores value in physical memory
288int store(int pid, int v_addr, int value)
289{
290 if (on_disk[pid][0] != -1)
291 {
292 int to_evict = evict(pid);
293 swap(to_evict, on_disk[pid][0]);
294 }
295 int phys_addr = translate_ptable(pid, v_addr);
296 int v_page= find_page(v_addr);
297 char buffer[10] = "";
298
299 if (write_list[pid][v_page] == 1)
300 {
301 if (page_exists[pid][v_page] == 1)
302 {
303 if (on_disk[pid][v_page + 1] != -1)
304 {
305 int to_evict = evict(pid);
306 swap(to_evict, on_disk[pid][v_page+1]);
307 //replace_page(pid, v_page);
308 }
309 sprintf(buffer, "%d", value);
310 int num_bytes = write_mem(phys_addr, buffer);
311 if (num_bytes == -1)
312 {
313 printf("ERROR: Write goes over end of page! Value not stored\n");
314 }
315 else
316 {
317 printf("Stored value %d at virtual address %d (physical address %d)\n", value, v_addr, phys_addr);
318 }
319 }
320 else
321 {
322 printf("ERROR: Virtual page %d has not been allocated for process %d!\n", v_page, pid);
323 }
324 }
325 else
326 {
327 printf("ERROR: Writes are not allowed to this page\n");
328 }
329
330 return 0; // Success
331}
332
333// Loads value from physical memory
334int load(int pid, int v_addr)
335{
336 int v_page = find_page(v_addr);
337 printf("On disk for pid %d: %d\n", pid, on_disk[pid][0]);
338 if (on_disk[pid][0] != -1)
339 {
340 int to_evict = evict(pid);
341 swap(to_evict, on_disk[pid][0]);
342 }
343 printf("On disk for v_page %d: %d\n", v_page, on_disk[pid][v_page + 1]);
344 if (on_disk[pid][v_page + 1] != -1)
345 {
346 int to_evict = evict(pid);
347 swap(to_evict, on_disk[pid][v_page+1]);
348 //replace_page(pid, v_page);
349 }
350 int phys_addr = translate_ptable(pid, v_addr);
351 int value = read_mem(phys_addr);
352 if (value == -1)
353 {
354 printf("ERROR: No value stored at virtual address %d (physical address %d)\n", v_addr, phys_addr);
355 }
356 else
357 {
358 printf("The value %d is virtual address %d (physical address %d)\n", value, v_addr, phys_addr);
359 }
360
361 return 0; // Success
362}
363
364// Chooses physical page to evict from memory
365// Current algorithm is round robin, will skip page if it is the process's page table
366int evict(int pid)
367{
368 int ptable = find_page(pid_array[pid]); // Physical page where pid's ptable is
369
370 int cur_evict = last_evict + 1;
371 if (cur_evict >= 4)
372 {
373 cur_evict = 0;
374 }
375 if (cur_evict == ptable)
376 {
377 cur_evict++;
378 if (cur_evict >= 4)
379 {
380 cur_evict = 0;
381 }
382 }
383
384 last_evict = cur_evict;
385 return cur_evict;
386}
387
388// Changes mapping of virtual page in a page table when swapping in from disk
389int remap(int pid, int v_page, int p_page)
390{
391 // Change physical address of page and overwrite entry in page table
392 char full_str[16] = "";
393 char buffer[10];
394 int been_allocated = -1;
395
396 int write_addr = pid_array[pid];
397 int v_flag = 1; // Whether specific entry is virtual page or not
398 int p_flag = 0; // Whether specific entry is a physical page or not
399 int correct_p = 0; // Flag for correct page to overwrite
400 for(int j = 0; j < 16; j++)
401 {
402 if (memory[write_addr] == ',') // Pointer on in-between position
403 {
404 if(memory[write_addr - 1] == v_page)
405 memory[write_addr + 1] = p_page;
406 }
407 write_addr++;
408 }
409
410 printf("Remapped virtual page %d into physical frame %d\n", v_page, p_page);
411
412
413 return 0; //Success
414}
415
416// Swaps page, handles array data for disk location
417int replace_page(int pid, int v_page)
418{
419 /*
420 int to_evict = evict(pid);
421 int disk_loc = -1;
422 if (v_page != -1)
423 {
424 disk_loc = on_disk[pid][v_page + 1];
425 if (disk_loc == -1) disk_loc = 0;
426 }
427 int new_line = -1;*/
428
429 // Find the process and page we are removing from memory
430 /*int r_pid = -1;
431 int r_vpage = -1;
432 for (int i = 0; i < MAXPROC; i++)
433 {
434 if (pid_array[i] != -1)
435 {
436 int cur_addr = pid_array[i];
437 for (int j = 0; j < 16; j++) // Only look up to end of page table virtual page
438 {
439 if (memory[cur_addr] == ',') // PTE Separator
440 {
441 if(memory[cur_addr + 1] - '0' == to_evict)
442 {
443 r_pid = i;
444 r_vpage = memory[cur_addr - 1] - '0';
445 printf("test1\n");
446 }
447 }
448 cur_addr++;
449 }
450 }
451 }
452
453 // Page table we need is on disk
454 int cur_ptable = -1;
455 if (r_pid == -1)
456 {
457 for (int i = 0; i < MAXPROC; i++)
458 {
459 cur_ptable = on_disk[i][0];
460 printf("test3: On disk for pid %d: is %d, table address is %d\n", i, on_disk[i][0], pid_array[i]);
461 if (on_disk[i][0] != -1)
462 {
463 swap(to_evict, cur_ptable);
464 pid_array[i] = find_address(to_evict);
465 int cur_addr = pid_array[i];
466 for (int j = 0; j < 16; j++) // Only look up to end of page table virtual page
467 {
468 if (memory[cur_addr] == ',') // PTE Separator
469 {
470 if(memory[cur_addr + 1] - '0' == to_evict)
471 {
472 r_pid = j;
473 r_vpage = memory[cur_addr - 1] - '0';
474 printf("test2\n");
475 }
476 }
477 cur_addr++;
478 }
479 }
480 if (r_pid != -1) break;
481 }
482 }*/
483/*
484 new_line = swap(to_evict, disk_loc); // Swap pages
485 free_list[to_evict] = -1; // Deallocated physical page
486 if (v_page != -1)
487 {
488 remap(pid, v_page); // Remaps swapped in page to a physical page
489 on_disk[pid][v_page + 1] = -1; // Update page that was swapped from disk
490 }
491 printf("Replace pid: %d, Replace v_page: %d\n", r_pid, r_vpage);
492 on_disk[r_pid][r_vpage + 1] = new_line; // Update page that was swapped to disk
493*/
494 return 0; // Success
495}
496
497// Swaps page from physical memory and disk, returns lineNum page was put in disk
498int swap(int page, int lineNum)
499{
500 int start = find_address(page);
501 char putTemp[16];
502 char getTemp[16];
503 int replaceMem = -1;
504 int putLine = -1;
505 int ptable_flag = -1;
506
507 // If page to swap is a page table, erase address in pid_array
508 for(int i = 0; i < MAXPROC; i++)
509 {
510 if (start == pid_array[i])
511 {
512 pid_array[i] = -1;
513 ptable_flag = i;
514 break;
515 }
516 }
517
518 for(int i = 0; i < 16; i++)
519 {
520 putTemp[i] = memory[start + i];
521 }
522
523 if(lineNum != -1) // If lineNum is -1, don't try to get something from disk
524 {
525 replaceMem = getFromDisk(&getTemp, lineNum);
526 free_list[page] = 0;
527 }
528 putLine = putToDisk(putTemp);
529
530 if(putLine == -1)
531 {
532 printf("ERROR: Could not put page to disk.\n");
533 return -1;
534 }
535 else if(replaceMem != -1)
536 {
537 for(int i = 0; i < 16; i++)
538 {
539 memory[start + i] = getTemp[i];
540 }
541 }
542 else // Cannot swap in new memory after putting old in disk, replace memory with empty page
543 {
544 for(int i = 0; i < 16; i++)
545 {
546 memory[start + i] = '*';
547 }
548 }
549
550 // Find the process & page we are putting in memory
551 if(lineNum != -1)
552 {
553 for(int i = 0; i < MAXPROC; i++)
554 {
555 for(int j = 0; j < MAXPROC + 1; j++)
556 {
557 if(on_disk[i][j] == lineNum)
558 {
559 on_disk[i][j] = -1;
560 if(j != 0)
561 remap(i, j - 1, page);
562 else if(j == 0 && ptable_flag == -1)
563 pid_array[i] = start;
564 break;
565 }
566 }
567 }
568 }
569
570 // Find the process and page we are removing from memory
571if(ptable_flag != -1) // Swapping out page instead of page table
572{
573 int r_pid = -1;
574 int r_vpage = -1;
575 // Page table in physical memory
576 for (int i = 0; i < MAXPROC; i++)
577 {
578 if (pid_array[i] != -1) // Find page table
579 {
580 int cur_addr = pid_array[i];
581 printf("cc page table of %d is ", i);
582 for (int j = 0; j < 16; j++) // Only look up to end of page table virtual page
583 {
584 printf("%c", memory[cur_addr]);
585 if (memory[cur_addr] == ',') // PTE Separator
586 {
587 if(memory[cur_addr + 1] - '0' == page)
588 {
589 r_pid = i;
590 r_vpage = memory[cur_addr - 1] - '0';
591 }
592 }
593 cur_addr++;
594 }
595 printf(" cc\n");
596 }
597 }
598 // Page table in disk
599 int cur_ptable = -1;
600 if (r_pid == -1)
601 {
602 for (int i = 0; i < MAXPROC; i++)
603 {
604 cur_ptable = on_disk[i][0]; // ptable location on disk
605 if (cur_ptable != -1)
606 {
607 replaceMem = getFromDisk(&getTemp, cur_ptable);
608 for (int j = 0; j < 16; j++) // Only look up to end of page table virtual page
609 {
610 if (getTemp[j] == ',') // PTE Separator
611 {
612 if(getTemp[j + 1] - '0' == page)
613 {
614 r_pid = j;
615 r_vpage = getTemp[j - 1] - '0';
616 }
617 }
618 }
619 }
620 if (r_pid != -1) break;
621 }
622 }
623 if(r_pid != -1 && r_vpage != -1)
624 {
625 on_disk[r_pid][r_vpage + 1] = putLine;
626 }
627 else
628 {
629 printf("ERROR: Page being swapped out doesn't exist in a process?\n");
630 }
631}
632 else
633 {
634 on_disk[ptable_flag][0] = putLine;
635 }
636
637
638 //logMem();
639 printf("Swapped frame %d to disk at swap slot %d\n", page, putLine);
640 if (lineNum != -1)
641 {
642 printf("Swapped disk slot %d into frame %d\n", lineNum, page);
643 }
644 if (ptable_flag != -1)
645 {
646 printf("Put page table for PID %d into swap slot %d\n", ptable_flag, putLine);
647 }
648 return putLine;
649}
650
651// Puts page in disk
652int putToDisk(char page[16])
653{
654 int line_placement = -1; // Where line is on disk
655 char currChar;
656 int pageCounter = 0; // Counts each character of a page
657
658 disk = fopen("disk.txt", "r+");
659 if(disk == NULL)
660 {
661 printf("ERROR: Cannot open disk in putToDisk.\n");
662 return -1;
663 }
664
665 do
666 {
667 currChar = fgetc(disk);
668 pageCounter++;
669
670 if(feof(disk)) // Empty file, put page in
671 {
672 for(int i = 0; i < 16; i++)
673 {
674 fputc(page[i], disk);
675 }
676 fputc('\n', disk);
677 line_placement = 0;
678 break;
679 }
680 else // Look for a free space
681 {
682 printf("%c", currChar);
683 if(pageCounter == 16)
684 {
685 line_placement++;
686 printf(" end \n");
687 }
688 if(currChar == '!' && pageCounter == 16) // This line in disk is free, all '!'
689 {
690 fseek(disk, -16, SEEK_CUR);
691 for(int i = 0; i < 16; i++)
692 {
693 fputc(page[i], disk);
694 }
695 break;
696 }
697 else if(pageCounter > 16)
698 {
699 pageCounter = 0;
700 }
701 }
702 }
703 while(currChar != EOF);
704
705 fclose(disk);
706 return line_placement;
707}
708
709// Gets page from disk
710int getFromDisk(char (*pageHolder)[16], int lineNum)
711{
712 int line_placement = -1; // Where line is on disk
713 char currChar;
714 int pageCounter = 0; // Counts each character of a page
715
716 disk = fopen("disk.txt", "r+");
717 if(disk == NULL)
718 {
719 printf("ERROR: Cannot open disk in getFromDisk.\n");
720 return -1;
721 }
722
723 do
724 {
725 currChar = fgetc(disk);
726 pageCounter++;
727
728 if(feof(disk) && line_placement == -1)
729 {
730 printf("ERROR: Cannot get page from empty disk.\n");
731
732 fclose(disk);
733 return -1;
734 }
735 else
736 {
737 if(pageCounter == 16)
738 {
739 line_placement++;
740 }
741 if(line_placement == lineNum && pageCounter == 16) // Get this line from disk
742 {
743 fseek(disk, -16, SEEK_CUR);
744 for(int i = 0; i < 16; i++)
745 {
746 currChar = fgetc(disk);
747 (*pageHolder)[i] = currChar;
748 fseek(disk, -1, SEEK_CUR);
749 fputc('!', disk); // Replace this line with a free line, all '!'
750 }
751 fputc('\n', disk);
752
753 fclose(disk);
754 return 0;
755 }
756 else if(pageCounter > 16)
757 {
758 pageCounter = 0;
759 }
760 }
761 }
762 while(currChar != EOF);
763
764 fclose(disk);
765 return -1;
766}
767
768// Main
769int main(int argc, char *argv[])
770{
771 int pid = 0; // Process ID
772 int inst_type = 0; // Instruction type
773 int v_addr = 0; // Virtual address
774 int input = 0; // Value
775 int is_end = 0; // Boolean for ending simulation
776
777 char buffer[20]; // Holds stdin buffer
778 char cmd_seq[20]; // The command sequence read from stdin
779 char* cmd_array[4]; // Holds the commands read from file
780 char* token;
781
782 // Clean disk
783 disk = fopen("disk.txt", "ab+");
784 if(disk == NULL)
785 {
786 printf("ERROR: Cannot open disk in main.");
787 return -1;
788 }
789 else
790 fclose(disk);
791
792 // Initialize ptable, free and write lists
793 for (int i = 0; i < MAXPROC; i++)
794 {
795 pid_array[i] = -1;
796 free_list[i] = -1;
797 for (int j = 0; j < MAXPAGE + 1; j++)
798 {
799 if (j < 4)
800 {
801 write_list[i][j] = 0;
802 page_exists[i][j] = 0;
803 }
804 on_disk[i][j] = -1;
805 }
806 }
807
808 // Initialize physical memory
809 for (int i = 0; i < SIZE; i++)
810 {
811 memory[i] = '*';
812 }
813
814 while (is_end != 1)
815 {
816 printf("Instruction?: ");
817 // Receive stdin
818 if (argc <= 1)
819 {
820 // Read sequence from file
821 if (fgets(buffer, sizeof(buffer), stdin) == NULL) {
822 printf("End of file. Exiting.\n");
823 exit(-1);
824 }
825 buffer[strcspn(buffer, "\n")] = 0;
826 strncpy(cmd_seq, &buffer[0], sizeof(cmd_seq));
827
828 // Parse sequence
829 token = strtok(cmd_seq, " ");
830 int i = 0;
831 while (token != NULL)
832 {
833 if (i >= 4)
834 {
835 printf("ERROR: Too many input arguments!\n");
836 break;
837 }
838 cmd_array[i] = token;
839 i++;
840 token = strtok(NULL, " ");
841 }
842
843 // Put sequence into variables
844 pid = atoi(cmd_array[0]);
845
846 if (strncmp(cmd_array[1], "map", sizeof(cmd_array[1])) == 0)
847 {
848 inst_type = 1;
849 }
850 else if (strncmp(cmd_array[1], "store", sizeof(cmd_array[1])) == 0)
851 {
852 inst_type = 2;
853 }
854 else if (strncmp(cmd_array[1], "load", sizeof(cmd_array[1])) == 0)
855 {
856 inst_type = 3;
857 }
858 v_addr = atoi(cmd_array[2]);
859 input = atoi(cmd_array[3]);
860 }
861
862 // Read argv
863 else
864 {
865 if (argc >= 2)
866 {
867 pid = atoi(argv[1]);
868 }
869 if (argc >= 3)
870 {
871 if (strncmp(argv[2], "map", sizeof(argv[2])) == 0)
872 {
873 inst_type = 1;
874 }
875 else if (strncmp(argv[2], "store", sizeof(argv[2])) == 0)
876 {
877 inst_type = 2;
878 }
879 else if (strncmp(argv[2], "load", sizeof(argv[2])) == 0)
880 {
881 inst_type = 3;
882 }
883 }
884 if (argc >= 4)
885 {
886 v_addr = atoi(argv[3]);
887 }
888 if (argc >= 5)
889 {
890 input = atoi(argv[4]);
891 }
892 }
893
894 if (is_end == 1) break; // Break if EOF
895
896
897 if (pid >= 4 || pid < 0)
898 {
899 printf("ERROR: Process ID %d is invalid! Only ID's 0 to 3 are allowed\n", pid);
900 }
901 else if (v_addr >= 64 || v_addr < 0)
902 {
903 printf("ERROR: Virtual address %d is invalid! Only virtual addresses 0 to 63 are allowed\n", v_addr);
904 }
905 else if (inst_type == 1)
906 {
907 map(pid, v_addr, input);
908 }
909 else if (inst_type == 2)
910 {
911 store(pid, v_addr, input);
912 }
913 else if (inst_type == 3)
914 {
915 load(pid, v_addr);
916 }
917 }
918
919 for (int i = 0; i < MAXPROC; i++)
920 {
921 printf("%d\n", pid_array[i]);
922 }
923 return 0;
924}