-
Notifications
You must be signed in to change notification settings - Fork 0
/
StatePrinter.c
247 lines (205 loc) · 8.96 KB
/
StatePrinter.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
/****************************************************************************
state_printer.c
Read Appendix D - output generation - in order to understand how
to use these routines.
The first portion of this file is SCHEDULER_PRINTER.
Revision History:
1.1 December 1990 Initial release
2.1 April 2001 Added memory_printer
2.2 July 2002 Make code appropriate for undergrads.
3.0 August 2004: Modified to support memory mapped IO
3.60 August 2012: Used student supplied code to add support
. for Mac machines
4.10 December 2013: Remove SP_setup_file and SP_setup_action
. Roll SP_ACTION_MODE into the routine SP_setup
. Define some new states.
4.20 May 2015: The way this code HAS been written is inherently
. STATEFUL. The code had a number of modes that needed
. to be filled in. Unfortunately, that meant that
. different threads tangled with each other.
****************************************************************************/
#include "global.h"
#include "syscalls.h"
#include "z502.h"
#include "protos.h"
#include "stdio.h"
#include "string.h"
#if defined LINUX || defined MAC
#include <unistd.h>
#endif
//
// This string is printed out as the header
#define SP_HEADER_STRING \
" Time Target Action Run State Populations \n"
// Prototypes for support routines
short SPDoOutput(char *text);
void SPLineSetup(char *, char *, INT16, INT16 *);
/****************************************************************************
SPPrintLine
SP_print_line prints out all the data that has been defined in the
SP_INPUT_DATA structure by the caller. The goal here is to make this
print operation atomic. It's not locked, but there's only one print
statement for the multi-line string.
ALL the data needed for the output is in the structure SP_INPUT_DATA which
is described in syscalls.h
****************************************************************************/
short SPPrintLine(SP_INPUT_DATA *Input) {
char OutputLine[900];
char temp[60];
// INT32 current_time;
MEMORY_MAPPED_IO mmio;
// print out the header
sprintf(OutputLine, "%s", SP_HEADER_STRING);
// Get the current time and place it in the output string
mmio.Mode = Z502ReturnValue;
mmio.Field1 = mmio.Field2 = mmio.Field3 = 0;
MEM_READ(Z502Clock, &mmio);
sprintf(temp, "%5d", (int) mmio.Field1 % 100000);
strcat(OutputLine, temp);
// If user defines the target PID, place it here
if (Input->TargetPID >= 0)
sprintf(temp, "%5d ", Input->TargetPID);
else
sprintf(temp, "%s", " ");
(void) strcat(OutputLine, temp);
sprintf(temp, " %8s", Input->TargetAction); /* Action */
(void) strcat(OutputLine, temp);
sprintf(temp, " %3d ", Input->CurrentlyRunningPID);
(void) strcat(OutputLine, temp);
// Multiple running processes is not implemented in Release 4.20
SPLineSetup(OutputLine, "RUNNING:", Input->NumberOfRunningProcesses,
Input->RunningProcessPIDs);
SPLineSetup(OutputLine, "READY :", Input->NumberOfReadyProcesses,
Input->ReadyProcessPIDs);
SPLineSetup(OutputLine, "SUS-PRC:", Input->NumberOfProcSuspendedProcesses,
Input->ProcSuspendedProcessPIDs);
SPLineSetup(OutputLine, "SUS-TMR:", Input->NumberOfTimerSuspendedProcesses,
Input->TimerSuspendedProcessPIDs);
SPLineSetup(OutputLine, "SUS-MSG:",
Input->NumberOfMessageSuspendedProcesses,
Input->MessageSuspendedProcessPIDs);
SPLineSetup(OutputLine, "SUS-DSK:", Input->NumberOfDiskSuspendedProcesses,
Input->DiskSuspendedProcessPIDs);
SPLineSetup(OutputLine, "TERM'S :", Input->NumberOfTerminatedProcesses,
Input->TerminatedProcessPIDs);
SPDoOutput(OutputLine); // We've accumulated the whole line - print it.
return 0;
} // End of SP_print_line
/****************************************************************************
SPLineSetup
Takes input from the user and packages it in a pretty fashion
char OutputText - the running string onto which all text is added
char *mode - character string describing the kind of pids we're working with
INT16 Number - how many processes are there in this category
INT16 ArrayOfPids - the process IDs in this category
****************************************************************************/
void SPLineSetup(char *OutputText, char *mode, INT16 Number,
INT16 ArrayOfPids[]) {
char Temp[64];
int index;
if (Number > 0) { // There are pids to deal with
strcat(OutputText, mode);
for (index = 0; index < Number; index++) {
sprintf(Temp, " %d", ArrayOfPids[index]);
(void) strcat(OutputText, Temp);
}
strcat(OutputText, "\n ");
}
} // End of SPLineSetup
/****************************************************************************
SPDoOutput
This little routine simply directs output to the screen.
****************************************************************************/
short SPDoOutput(char *text) {
printf("%s\n", text);
return 0;
} /* End of SP_do_output */
/****************************************************************************
Read Appendix D - output generation - in order to understand how
to use these routines.
The second portion of this source file is MEMORY_PRINTER.
This is the definition of the table we will produce here.
A Frame 0000000000111111111122222222223333333333444444444455555555556666
B Frame 0123456789012345678901234567890123456789012345678901234567890123
C PID 0000000001111
D VPN 0000000110000
E VPN 0000111000000
F VPN 0000000220000
G VPN 0123567230123
H VMR 7775555447777
The rows mean the following:
A - B: The frame number. Note how the first column is "00" and the
. last column is "63".
C: The Process ID of the process having it's virtual page in the
. frame table.
D - G: The virtual page number of the process that's mapped to that
. frame. Again the number (from 0 to 1023 possible) is written
. vertically.
H: The state of the page. Valid = 4, Modified = 2,
. Referenced = 1. These are OR'd (or added) together.
Example: The page in frame 6 is virtual page 107 in process 0. That
page has been made valid and has been referenced.
****************************************************************************/
/****************************************************************************
MPPrintLine
Outputs everything we know about the state of the physical memory.
****************************************************************************/
short MPPrintLine(MP_INPUT_DATA *Input) {
char OutputLine[1200];
INT32 index;
INT32 Temporary;
char temp[120];
char output_line3[PHYS_MEM_PGS + 5];
char output_line4[PHYS_MEM_PGS + 5];
char output_line5[PHYS_MEM_PGS + 5];
char output_line6[PHYS_MEM_PGS + 5];
char output_line7[PHYS_MEM_PGS + 5];
char output_line8[PHYS_MEM_PGS + 5];
// Header Line
strcpy(OutputLine, "\n PHYSICAL MEMORY STATE\n");
// First Line
strcat(OutputLine,
"Frame 0000000000111111111122222222223333333333444444444455555555556666\n");
// Second Line
strcat(OutputLine,
"Frame 0123456789012345678901234567890123456789012345678901234567890123\n");
// Third - Eighth Line
strcpy(output_line3,
" \n");
strcpy(output_line4,
" \n");
strcpy(output_line5,
" \n");
strcpy(output_line6,
" \n");
strcpy(output_line7,
" \n");
strcpy(output_line8,
" \n");
// Here we take the input data and arrange it artfully for our output
for (index = 0; index < PHYS_MEM_PGS ; index++) {
if (Input->frames[index].InUse == TRUE) {
output_line3[index] = (char) (Input->frames[index].Pid + 48);
Temporary = Input->frames[index].LogicalPage;
output_line4[index] = (char) (Temporary / 1000) + 48;
output_line5[index] = (char) ((Temporary / 100) % 10) + 48;
output_line6[index] = (char) ((Temporary / 10) % 10) + 48;
output_line7[index] = (char) ((Temporary) % 10) + 48;
output_line8[index] = (char) Input->frames[index].State + 48;
}
}
sprintf(temp, "PID %s", output_line3);
strcat(OutputLine, temp);
sprintf(temp, "VPN %s", output_line4);
strcat(OutputLine, temp);
sprintf(temp, "VPN %s", output_line5);
strcat(OutputLine, temp);
sprintf(temp, "VPN %s", output_line6);
strcat(OutputLine, temp);
sprintf(temp, "VPN %s", output_line7);
strcat(OutputLine, temp);
sprintf(temp, "VMR %s", output_line8);
strcat(OutputLine, temp);
SPDoOutput(OutputLine);
return 0;
} // End of MPPrintLine