Examples of IO, Interrupts, and Exceptions

Transcription

1 Examples of IO, Interrupts, and Exceptions Andy Wright, Thomas Bourgeat, Silvina Hanono Wachman Computer Science & Artificial Intelligence Lab. Massachusetts Institute of Technology L15-1

2 Keyboard Input Hardware: n Box with buttons on it, with 32 wires coming out of it. Wires encode what button is pushed in ASCII. Wires transmit -1 if nothing is pushed. Interface: n When we perform a load from address 0x , we don t load from memory, we return the value from the keyboard s wires. n li t0, 0x ; lw t0, 0(t0) n We say that the keyboard is memorymapped IO L15-2

3 Problems with Keyboard It is software s responsibility to keep checking if a key has been pressed Its possible to miss characters if you don t poll fast enough If you see the same character twice in a row, was it pressed once or twice? What if you cache the keyboard s address? n Check if address is MMIO before looking in cache L15-3

4 Bufferized Keyboard I/O Whenever a key is pressed, add it to a hardware FIFO buffer of size N When the software wants a key from the keyboard, it dequeues from the FIFO buffer n Loading from 0x will return the first element from the FIFO and dequeue from the FIFO. If the FIFO is empty, the load will return -1. L15-4

5 Bufferized Keyboard I/O Hardware Implementation if (dinst.itype == Load) begin if (einst.addr == 0x ) begin if (keyboardfifo.notempty) begin einst.data = keyboardfifo.first; keyboardfifo.deq; end else begin einst.data = -1; end state <= Fetch; end else begin mem.req( ); // actual memory req state <= LoadWait; end end L15-5

6 Bufferized Keyboard I/O Problems Some problems solved n Pressing key twice easily detected Other problems remain n Can miss characters if buffer fills up before polling Can we switch to a SW buffer which is capable of increasing its size dynamically? L15-6

7 SW Bufferized I/O Can t rely on polling the keyboard s address n Need a way for the keyboard to interrupt the program ( ring the doorbell ) We split reading keyboard characters into two parts: n KeyPress: When the key is pressed, the keyboard generates an interrupt, and the handler reads from keyboard and enqueues into software buffer n ReadChar: When the program wants to read a character, it reads from the software buffer L15-7

8 Interrupt (aka Trap) altering the normal flow of control I i-1 HI 1 program I i HI 2 interrupt handler I i+1 HI n An external or internal event that needs to be processed by another (system) program. The event is usually unexpected or rare from program s point of view. L15-8

9 KeyPress Hardware n n I/O Device: w New wire from keyboard: InterruptReq (high when key is pressed) Processor: w An interrupt is taken when the Keyboard s InterruptReq is high w Interrupt stops current program and jumps to an interrupt handler to deal with it Software: n n Interrupt handler adds the pressed key to the software buffer Returns to the original program with original register values intact w Program can t tell interrupt happened L15-9

10 KeyPress Hardware Part of Implementation if (keyboard.interruptreq == 1) begin // take an interrupt // store current pc as epc mepc <= pc; // cause = external interrupt mcause <= 32 h ; // jump to trap vector pc <= mtvec; state <= Fetch; end L15-10

11 KeyPress Software Part of Implementation get_keypress: li t0, 0x lw a0, 0(t0) ret mtvec: // store all registers to the stack jal get_keypress jal add_to_kb_buffer // restore all registers from the stack mret L15-11

12 KeyPress Software Part of Implementation std::list<int> kb_buffer; void add_to_kb_buffer(int key) { if (key!= -1) { // enqueue into kb_buffer kb_buffer.push_back(key); } } L15-12

13 ReadChar Software: n Reads the oldest character in the software keyboard buffer L15-13

14 ReadChar Software Implementation std::list<int> kb_buffer; int get_from_kb_buffer() { int key = -1; if (kb_buffer.size()!= 0) { // dequeue from kb_buffer key = kb_buffer.front(); kb_buffer.pop_front(); } return key; } L15-14

15 Other Use of Keyboard Interrupt Interrupt triggers even when software doesn t want keyboard input n This allows for the ctrl-c keyboard combination to kill busy programs L15-15

16 Ctrl-C Software Implementation std::list<int> kb_buffer; void add_to_kb_buffer(int key) { if (key == CTRL_C) { abort(); } if (key!= -1) { // enqueue into kb_buffer kb_buffer.push_back(key); } } L15-16

17 Exceptions Exceptions are caused by executing instructions n n n Unimplemented instruction Instructions that cause an error w Misaligned load/store w Illegal address w Insufficient permissions Exceptions are handled similarly to Interrupts n n n mcause gets code corresponding to exception type mepc gets pc of the faulting instruction pc changes to mtvec L15-17

18 Illegal Instruction Exception Hardware Implementation If (dinst.itype == Unsupported) begin mcause <= 2; // code for illegal instruction end mepc <= pc; pc <= mtvec; state <= Fetch; L15-18

19 Implementing Mul Instruction in SW Our RISC-V subset doesn t have the mul rd, rs1, rs2 instruction n Executing it will result in an Illegal Instruction exception (mcause = 2) n The exception handler can emulate the instruction and return to the program at mepc+4 w Requires incrementing mepc by 4 before mret n To the program, it will look like the mul instruction worked L15-19

20 Common Interrupt Handler Assembly Code // This replaces old mtvec from keyboard example mtvec: // store all registers to the stack csrr a0, mcause csrr a1, mepc mv a2, sp // where registers are saved jal ih_dispatcher // ih_dispatcher returns next address to execute csrw mepc, a0 // restore all registers from the stack mret L15-20

21 Common Interrupt Handler C Code int ih_dispatcher(int cause, int epc, int *regs) { if (cause == 2) { } return illegal_inst_ih(epc, regs); } if (cause == 0x ) { return keyboard_ih(epc, regs); } else { abort(); } L15-21

22 Interrupt Handler Keyboard Interrupt int keyboard_ih(int cause, int epc) { } int key = get_keypress(); add_to_kb_buffer(key); return epc; L15-22

23 Interrupt Handler Illegal Instruction int illegal_inst_ih(int epc, int *regs) { int inst = load_mem(epc); // load_mem fetches inst // check opcode & function codes if((inst & MASK_MUL) == MATCH_MUL) { // is MUL, extract rd, rs1, rs2 from inst int rd = (inst >> 7) & 0x01F; int rs1 =...; int rs2 =...; // emulate regs[rd] = regs[rs1] * regs[rs2] multiply(rd, rs1, rs2, regs); return epc + 4; // done, resume at epc+4 } else abort(); } L15-23