1 / 23

ECE291 Computer Engineering II Lecture 14

ECE291 Computer Engineering II Lecture 14. Dr. Zbigniew Kalbarczyk University of Illinois at Urbana- Champaign. Outline. Hash functions Interrupt driven I/O Interrupt service routines (ISR). Hash Functions.

radha
Download Presentation

ECE291 Computer Engineering II Lecture 14

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. ECE291Computer Engineering IILecture 14 Dr. Zbigniew Kalbarczyk University of Illinois at Urbana- Champaign

  2. Outline • Hash functions • Interrupt driven I/O • Interrupt service routines (ISR) ECE291

  3. Hash Functions • Consider using a table lookup when the input (I) can span a large range of values but is sparsely populated. • Example: • Count incoming packets from each of 100 hosts scattered throughout the Internet using the 32-bit IP source address. • A Table-Lookup would require 4 billion table entries, most of which would be empty. ECE291

  4. Hash Functions (cont.) • A Hash Function, H(x), can be used to re-map the four-byte (W.X.Y.Z) IP address to smaller (8-bit) value. • H(W.X.Y.Z)=W xor X xor Y xor Z H(128.174.5.58) = 17 H(224.2.4.88) = 190 H(141.142.44.33) = 14 Hash Table Index IP address 0 ….. …… 14 141.142.44.33 ….. 17 128.174.5.58 …. 190 224.2.4.88 ….. ECE291

  5. Hash Functions Issues • Collisions, can occur when two inputs map to the same output. • Collision Resolution: Linear Probing • Use next-available location in the hash table • Add an extra identifier (a tag) to distinguish different entries in the table, example (simplest algorithm) to retrieve data: tag = IP_addressTag i = h(IP_address); if (ht[i].tag == IP_addressTag) then <Done> else <search the hash table until the entry with matching Tag is found> ECE291

  6. Interrupt Vectors • The term interrupt is used in three different contexts: • Software interrupts (e.g., 21h) • provide a mechanism whereby the programmer can use the int instruction to access blocks of code that already exist and are resident in machine memory • Hardware interrupts • triggered by hardware events external to the microprocessor, rather than resulting from an int or any other instruction • e.g., request for service by external devices such as disk drives • Exceptions • hardware origin within the microprocessor itself • e.g., anomalous event within a program, such as an attempt to divide by zero ECE291

  7. Interrupt Driven I/O • Consider an I/O operation, where the CPU constantly tests a port (e.g., keyboard) to see if data is available • CPU polls the port if it has data available or can accept data • Polled I/O is inherently inefficient • Wastes CPU cycles until event occurs • Analogy: Checking your watch, standing at the door ... • Solution is to provide an interrupt driven I/O • Perform regular work until an event occurs • Process event when it happens, then resume normal activities • Analogy: Alarm clock, doorbell, telephone ring ... ECE291

  8. Interrupting an 80x86 Microprocessor Interrupt signal (pin) on the 80x86 CPU 8259 Programmable Interrupt Controller (typically built into motherboard chipset) ISA/PCI System Bus (pins defined for IRQ signals) Peripheral Devices (example) IRQ 0: Timer (triggered 18.2/second) IRQ 1: Keyboard (keypress) IRQ 2: PIC IRQ 3: Serial Ports (Modem, network) IRQ 5: Audio card IRQ 6: Floppy (read/write completed) IRQ 8: Real-time Clock IRQ 12: Mouse IRQ 13: Math Co-Processor IRQ 14: IDE Hard-Drive Controller ECE291

  9. Complete current instruction Preserve current context PUSHF Store flags to stack Clear Trap Flag (TF) & IF (Interrupt Flag) Store return address to stack PUSH CS, PUSH IP Identify Source Read 8259 PIC status register Determine which device (N) triggeredinterrupt Activate Interrupt Service Routine Use N to index vector table Read CS/IP from table Jump to instruction Execute Interrupt Service Routine usually the handler immediately re-enables the interrupt system (to allow high priority interrupts to occur) process the interrupt Indicate End-Of-Interrupt (EOI) to 8259 PIC mov al, 20h out 20h, al ;transfers the contents of AL to I/O port 20h Return (IRET) POP IP (Far Return) POP CS POPF (Restore Flags) Servicing an Interrupt ECE291

  10. Interrupt Service Routines (ISR) • Reasons for writing your own ISR • to supersede the default ISR for internal hardware interrupts (e.g., division by zero) • to chain your own ISR onto the default system ISR for a hardware device, so that both the system’s actions and your own will occur on an interrupt (e.g., clock -tick interrupt) • to service interrupts not supported by the default device drivers • to provide communication between a program that terminates and stays resident and other application software ECE291

  11. Interrupt Service Routines (ISR) • DOS facilities to enable ISR • Restrictions • Currently running program should have no idea that it was interrupted. • ISR should never make DOS call during the actual interrupt processing • DOS calls are non-reentrant,i.e., expect single execution Function Action INT 21h Function 25h Set Interrupt vector INT 21h Function 35h Get Interrupt vector INT 21h Function 31h Terminate and stay resident ECE291

  12. Interrupt Service Routines • ISRs are meant to be short. • keep the time that interrupts are disable and the total length of the service routine to an absolute minimum • remember after interrupts are re-enabled (STI instruction), interrupts of the same or lower priority remain blocked if the interrupt was received through the 8259A PIC • ISRs can be interrupted. • ISRs must be in memory • Option 1: Redefine interrupt only while your program is running • the default ISR will be restored when the executing program terminates • Option 2: Use DOS Terminate-and-Stay-Resident (TSR) command • the ISR stays permanently in machine memory ECE291

  13. Installing ISR Let N==interrupt to service • Read current function pointer in vector table • Use DOS function 35h • Set AL=N • Call DOS Function AH=35h, INT 21h • Returns: ES:BX = Address stored at vector • Set new function pointer in vector table • Use DOS function 25h • Set DS:DX=New Routine • Set AL=N • DOS Function AH=25h, INT 21H ECE291

  14. Interrupts can be installed, chained, or called Install New interrupt (replace old interrupt) Chain into interrupt Service MyCode first Call Original Interrupt Service MyCode last Installing ISR MyIntVector PROC FAR …... Save Registers MyCode Restore Registers …. JMP CS:Old_Vector MyIntVector ENDP MyIntVector PROC FAR .. Save Registers Service Hardware Reset PIC Restore Registers ….. IRET MyIntVector ENDP MyIntVector PROC FAR …... PUSHF CALL CS:Old_Vector….. Save Registers MyCode Restore Registers …... IRET MyIntVector ENDP ECE291

  15. ;====== Variables =================== ; Old Vector (far pointer to old interrupt function) oldv DD ? count DW 0 ; Interrupt counter (1/18 sec) scount DW 0 ; Second counter mcount DW 0 ; Minute counter ;====== Main procedure ===== main proc far … ; ---- Install Interrupt Routine----- call Install ; Main Body of Program (print count values) showc: mov ax, mcount ;Minute Count .. call pxy mov ax, scount ; Second Count .. call pxy mov ax,count ;Interrupt Count (1/18 sec) … call pxy mov ah,1 int 16h ; Check for key press jz showc ; (Quit on any key) ; ---- Uninstall Interrupt Routine----- call UnInst; Restore original INT8 … main end Timer Interrupt(Main Proc Skeleton) ECE291

  16. main proc far mov ax, cseg ; Initialize DS=CS mov ds, ax mov ax,0B800h ;ES=VideoTextSegment mov es, ax call Install; Insert my ISR showc: mov ax,mcount ; Minute Count mov bx,offset pbuf call binasc mov bx,offset pbuf mov di,0 ; Column 0 mov ah,00001100b ; Intense Red call pxy mov ax,scount ; Second Count mov bx,offset pbuf call binasc mov bx, offset pbuf mov di,12 ; Column 6 (DI=12/2) mov ah,00001010b ; Intense Green call pxy mov ax,count ;Interrupt Count (1/18th sec) mov bx,offset pbuf call binasc mov bx,offset pbuf mov ah,00000011b ; Cyan mov di,24 ; Column 12 (DI=24/2) call pxy mov ah,1 int 16h ; Key Pressed ? jz showc Call UnInst ; Restore original INT8 mov ax,4c00h ; Normal DOS Exit int 21h ret main endp Timer Interrupt(Complete Main Proc) ECE291

  17. ;====== Helper Function ============= pxy proc near ; Prints Text on Screen push es ; (Not relevant to interrupts) pxyl: mov al, [bx] cmp al, ‘$' je pxydone mov es:[di+2000], ax inc bx add di,2 jmp pxyl pxydone: pop es pxy endp ;====== Install Interrupt ===== Install proc near ; Install new INT 8 vector push es push dx push ax push bx mov al, 8 ; INT = 8 mov ah, 35h ;Subfunction = ReadVector int 21h ; DOS Service mov word ptr Oldv+0, bx mov word ptr Oldv+2, es mov al, 8 ; INT = 8 mov ah, 25h ;Subfunction = Set Vector mov dx, offset myint ;DS:DX point to function int 21h ; DOS Service pop bx pop ax pop dx pop es ret Install endp Timer Interrupt Install Interrupt ECE291

  18. ;====== Uninstall Interrupt =========== UnInst proc near ; Uninstall Routine (Reinstall old vector) push ds push dx push ax mov dx, word ptr Oldv+0 mov ds, word ptr Oldv+2 mov al, 8 ; INT = 8 mov ah, 25h ; Subfunction = Set Vector int 21h ; DOS Service pop ax pop dx pop ds ret UnInst endp Timer Interrupt Uninstall Interrupt ECE291

  19. ;====== ISR Code ========= myint proc near push ds; Save all registers push ax mov ax, cs; Load default segment mov ds, ax pushf;Call Orig Functionw/flags call oldv;Far Call to existingroutine inc count; Increment Interrupt count cmp count,18 jne myintd inc scount ; Next second mov count, 0 cmp scount, 60 jne myintd inc mcount ; Next minute mov scount, 0 myintd: mov al, 20h ;Reset the PIC out 20h, al ;(End-of-Interrupt signal) pop ax ; Restore all Registers pop ds iret ; Return from Interrupt myint endp Timer Interrupt ISR Code ECE291

  20. ;install new interrupt vector setInt MACRO Num, OffsetInt, SegmentInt push ax push dx push ds mov dx, OffsetInt mov ax, SegmentInt mov ds, ax mov al, Num mov ah, 25h ;set interrupt vector int 21h pop ds pop dx pop ax endm ;store old interrupt vector getInt MACRO Num, OffsetInt, SegmentInt push bx push es mov al, Num mov ah, 35h ;get interrupt vector int 21h mov OffsetInt, bx mov SegmentInt, es pop es pop bx endm Replacing An Interrupt Handler ECE291

  21. Title New04h.asm CR EQU 0dh LF EQU 0ah stkseg segment stack db 64 dup ('STACK ') stkseg ends ;====== Define code segment cseg segment public 'CODE' assume cs:cseg, ds:cseg, ss:stkseg, ;===Declare variables for main procedure Warning BYTE 'Overflow - Result Set to ZERO!!!!',CR, LF,0 msgOK BYTE 'Normal termination', CR, LF, 0 old04hOffset WORD ? old04hSegment WORD ? main proc far mov ax, cseg mov ds, ax ;store old vector getInt 04h, old04hOffset, old04hSegment ;replace with address of new int handler setInt 04h, <OFFSET New04h>, cs mov al, 100 add al, al into ;calls int 04 - an overflow test ax, 0FFh jz Error Replacing An Interrupt Handler ECE291

  22. mov ax, OFFSET msgOK push ax call putStr Error: ;restore original int handler setInt 04h, old04hOffset, old04hSegment mov ax, 4c00h int 21h main endp Replacing An Interrupt Handler (cont.) ECE291

  23. New04h PROC NEAR sti ;reenable interrupts mov ax, OFFSET Warning push ax call putStr xor ax, ax cwd ; AX to DX:AX ;mov ax, 4c01h ;int 21h iret New04h ENDP NOTES INTO is a conditional instruction that acts only when the overflow flag is set With INTO after a numerical calculation the control can be automatically routed to a handler routine if the calculation results in a numerical overflow. By default Interrupt 04h consists of an IRET, so it returns without doing anything. Replacing An Interrupt Handler ECE291

More Related