Question 7) Consider a \"unix\" filesystem where: [6 marks] All i-nodes are cach

Question

Question 7) Consider a "unix" filesystem where: [6 marks] All i-nodes are cached in RAM ·i-nodes have 10-direct pointers, 2 indirect pointers and 3 double indirect pointers. Blocks are 8KB . Block pointers are 16Bytes blocks are numbered from 0. A) What is the maximum possible file size for this file system? [2 marks] B) How many blocks (in total) must be accessed to read the following blocks from a file: 0,1,2, 4012,8009 2 marks C) What is the number of the first block in a large file which needs to use the second double indirect pointer? 2 marks]

Explanation / Answer

#define MEMLEN 100
#define NREG 10

struct CPU {
Word mem[MEMLEN];
Word reg[NREG]; // Note: "register" is a reserved word
Address pc; // Program Counter
int running; // running = 1 iff CPU is executing instructions
Word ir; // Instruction Register
int instr_sign; // sign of instruction
int opcode; // opcode field
int reg_R; // register field
int addr_MM; // memory field
};
typedef struct CPU CPU;

// Prototypes [note the functions are also declared in this order]
//
// ** STUB ** Lab 5 items omitted ....

int read_execute_command(CPU *cpu);
int execute_command(char cmd_char, CPU *cpu);
void help_message(void);
void many_instruction_cycles(int nbr_cycles, CPU *cpu);
void one_instruction_cycle(CPU *cpu);

void exec_HLT(CPU *cpu);
// ** STUB **

// Main program: Initialize the cpu, and read the initial memory values.
// Then run the command loop to let the user execute the program.
//
int main(int argc, char *argv[]) {
printf("SDC Simulator pt 2 for **Your name, Lab section ** "); // STUB
CPU cpu_value, *cpu = &cpu_value;

// ** STUB ** Lab 5 items omitted (initialize CPU and memory) ....

// Run the command loop
//
char *prompt = "> ";
printf(" Beginning execution; type h for help %s", prompt);

int done = read_execute_command(cpu);
while (!done) {
printf("%s", prompt);
done = read_execute_command(cpu);
}
return 0;
}

// ** STUB ** Rest of Lab 5 items omitted
// (initialize_control_unit, ..., print_instr)

// Read a simulator command from the keyboard (q, h, ?, d, number,
// or empty line) and execute it. Return true if we hit end-of-input
// or execute_command told us to quit. Otherwise return false.
//
int read_execute_command(CPU *cpu) {
// Buffer to read next command line into
#define CMD_LINE_LEN 256
char cmd_line[CMD_LINE_LEN];
char *read_success; // NULL if reading in a line fails.

int nbr_cycles; // Number of instruction cycles to execute
char cmd_char; // Command 'q', 'h', '?', 'd', or ' '
int done = 0; // Should simulator stop?

read_success = fgets(cmd_line, CMD_LINE_LEN, stdin);

// ** STUB ** done if we have we hit eof

// ** STUB **
// while not done,
// Handle q, h, ?, d commands, integer (nbr of instruction cycles),
// or empty line (one instruction cycle)
// Read next command line, check for eof

return done;
}

// Execute a nonnumeric command; complain if it's not 'h', '?',
// 'd', 'q' or ' '. Return true for the q command, false otherwise.
//
int execute_command(char cmd_char, CPU *cpu) {
if (cmd_char == '?' || cmd_char == 'h') {
help_message();
}
// ** STUB ***
return 0;
}

// Print standard message for simulator help command ('h' or '?')
//
void help_message(void) {
// ** STUB ***
}

// Execute a number of instruction cycles. Exceptions: If the
// number of cycles is <= 0, complain and return; if the CPU is
// not running, say so and return; if the number of cycles is
// unreasonably large, warn the user and substitute a limit.
//
// If, as we execute the many cycles, the CPU stops running,
// just stop and return.
//
void many_instruction_cycles(int nbr_cycles, CPU *cpu) {
int REASONABLE_NBR_CYCLES = 100;

// ** STUB ***
}

// Execute one instruction cycle
//
void one_instruction_cycle(CPU *cpu) {
// If the CPU isn't running, say so and return.
// If the pc is out of range, complain and stop running the CPU.
//
// ** STUB ***

// Get instruction and increment pc
//
// For printing purposes, we'll save the location of
// the instruction (the pc before the increment).
//
int instr_loc = cpu -> pc;
cpu -> ir = cpu -> mem[cpu -> pc];
(cpu -> pc)++;

// Decode instruction into opcode, reg_R, addr_MM, and instruction sign
//
// ** STUB ***

// Echo instruction
// ** STUB **

switch (cpu -> opcode) {
case 0: exec_HLT(cpu); break;
// ** STUB ***
default: printf("Bad opcode!? %d ", cpu -> opcode);
}
}

// Execute the halt instruction (make CPU stop running)
//
void exec_HLT(CPU *cpu) {
// ** STUB ** Print a message?
cpu -> running = 0;
}

Related Questions

Navigate

• Browse (All)
• Browse Q
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.