Week 9: Direct Memory Access (DMA) Simulation

1. Simulated DMA Byte Transfer with Offset: Transfers data from a source array to a destination
array with an added offset, similar to a DMA with an offset function.

asm

org 100h
source DB 'DMA Transfer', 0
destination DB 12 DUP('?') ; destination for the transferred data

mov si, offset source

mov di, offset destination + 2 ; start destination with an offset of 2 bytes
mov cx, 12 ; number of bytes to transfer

cld ; clear direction flag

rep movsb ; transfer bytes from source to destination
hlt

2. Block Copy Using `movsw` (Word Transfers): Copies a block of data in 2-byte (word) units to
simulate DMA operations with word-sized transfers.

asm

org 100h
dataBlock DW 1234h, 5678h, 9ABCh, DEF0h
destinationBlock DW 4 DUP(?)

mov si, offset dataBlock

mov di, offset destinationBlock
mov cx, 4 ; word count for the transfer

cld ; clear direction flag

rep movsw ; transfer words
hlt

3. DMA Data Transfer with Masking: Simulates a DMA-like transfer with an added mask to each
byte.

asm

org 100h
source DB 0Fh, 1Eh, 2Dh, 3Ch ; source block
destination DB 4 DUP('?') ; destination block
mask DB 0FFh ; mask value

mov si, offset source

mov di, offset destination
mov cx, 4 ; number of bytes to transfer

cld ; clear direction flag

transfer:
lodsb ; load source byte into al
and al, mask ; apply mask
stosb
hlt ; store result in destination
Week 10: Arithmetic and Logic Instructions

1. Mixed Arithmetic Operations: Uses various arithmetic instructions to calculate a complex

expression.

asm

org 100h
mov ax, 5
add ax, 3 ; ax = 5 + 3
mov bx, 4
mul bx ; ax = ax * 4
sub ax, 6 ; ax = ax - 6
hlt

2. Shift Operations: Shifts bits in `ax` to demonstrate bitwise shift operations for multiplication
and division.

asm

org 100h
mov ax, 4
shl ax, 1 ; ax = ax * 2 (multiply by 2)
shr ax, 2 ; ax = ax / 4 (divide by 4)
hlt

3. Bitwise Logic Combination: Uses `AND`, `OR`, `XOR`, and `NOT` to manipulate individual bits in a
register.

asm

org 100h
mov ax, 0AAAAh ; initial value with alternate bits set
and ax, 0F0F0h ; clear specific bits with AND
or ax, 0F00Fh ; set specific bits with OR
xor ax, 0FFFFh ; invert all bits with XOR
not ax ; bitwise NOT to flip all bits
hlt
 Week 11: Control Flow Instructions (JMP, LOOP, CALL, RET)

1. Conditional Jump Example: Uses `JMP` and conditional jumps to control program flow based on
a comparison.

org 100h
mov ax, 5
cmp ax, 3
ja greater ; jump if ax > 3
mov ax, 1 ; executed if ax <= 3
jmp end

greater:
mov ax, 10 ; executed if ax > 3
end:
hlt

2. Loop with Nested Calls: Demonstrates nested function calls and returns within a loop.

asm

org 100h
mov cx, 3 ; loop 3 times

loop_start:
call display_message
loop loop_start
hlt

display_message:
; assume a print routine here
ret

3. Recursive Call Simulation: Uses `CALL` and `RET` to simulate recursion by looping over a
decrementing register.

asm

org 100h
mov ax, 5 ; initial value

call decrement
hlt

decrement:
dec ax
cmp ax, 0
jne decrement ; recurse if ax != 0
ret
Week 12: Interrupts and Exception Handling

1. Keyboard Input Interrupt (`INT 16h`): Waits for a key press using a BIOS interrupt, commonly
used in older systems.

org 100h
mov ah, 0 ; function for waiting key press
int 16h ; BIOS interrupt for keyboard input
hlt

2. Display Character on Screen (`INT 10h`): Uses BIOS interrupt to display a character on the
screen.

asm

org 100h
mov ah, 0Eh ; function to print character
mov al, 'A' ; character to display
int 10h ; BIOS interrupt for display
hlt

3. Software Interrupt to Trigger a Handler: Demonstrates the use of a software interrupt to

trigger a routine, simulating interrupt-driven execution.

asm

org 100h
int 3 ; software interrupt (often used for breakpoints)
hlt
Week 13: Instruction Pipelining Simulation

1. Loop Unrolling for Faster Execution: Simulates pipelining by manually unrolling a loop.

asm

org 100h
mov ax, 0

add ax, 1 ; first iteration

add ax, 1 ; second iteration
add ax, 1 ; third iteration
add ax, 1 ; fourth iteration
hlt

2. Multiple Sequential Instructions: Arranges independent instructions in sequence to mimic a

simple
asm pipeline.

org 100h
mov ax, 10
mov bx, 20

mov cx, 30
add ax, bx ; independent operations for pipelining simulation
add cx, bx
sub bx, ax
hlt

3. Independent Operations within a Loop: Demonstrates pipelining by separating operations in a

loop.

asm

org 100h
mov cx, 4

loop_start:
add ax, 2 ; first independent operation
sub bx, 1 ; second independent operation
add dx, 3 ; third independent operation
loop loop_start
hlt
 1.

Purpose: This program finds the largest element in an array, which ends with `0xaa` as an end
marker. The largest element found is stored in the `dx` register.

asm

; Find the largest element in an array ending with 0xaa

org 100h
ARRAY DB 11h, 22h, 88h, 99h, 33h, 77h, 44h, 55h, 0xaa

cld ; clear direction flag

mov si, offset ARRAY
mov bx, 0 ; initialize max storage
l0: lodsb ; load next byte to al
cmp al, 0xaa ; check if end of array
jz end
cmp al, bx ; compare with current max in bx
jb continue
mov bx, al ; update max if al is greater
continue: jmp l0
end: mov dx, bx ; store max in dx
hlt

2.

Purpose: This program calculates the absolute difference between the values in `ax` and `bx`,
storing the result in `dx`.

asm

; Calculate absolute difference of ax and bx, store in dx

mov ax, 5678h
mov bx, 1234h

cmp ax, bx
jc DIFF2 ; jump if ax < bx
DIFF1: mov dx, ax
sub dx, bx
jmp DONE
DIFF2: mov dx, bx
sub dx, ax
DONE: ret
3.

Purpose: Adds values in `ax` and `bx` and stores the sum in `dx`.

asm

; Sum of ax and bx, result in dx

org 100h
mov ax, 1234h
mov bx, 4321h
call sumAxBx
hlt

sumAxBx proc
mov dx, 0
add dx, ax
add dx, bx
ret
sumAxBx endp

4.

Purpose: Demonstrates `push` and `pop` with registers `ax` and `bx`.

asm

; Demonstrate push and pop with ax and bx

mov ax, 34h
mov bx, 78h

push ax
push bx

pop ax
pop bx
5.

Purpose: Counts odd and even numbers in an array, storing the counts in `bx` (odd) and `dx`
(even).

asm

; Count odd and even numbers in an array

org 100h

ARRAY DW 8, 11, 43, 56, 507, 608, 0, 123, 17, 13

count DW 10

cld ; auto-increment
mov cx, count
mov si, offset ARRAY
mov bx, 0 ; odd count
mov dx, 0 ; even count

l0: lodsw ; load word

shr ax, 1 ; check LSB for even/odd
jnc even ; jump if even
inc bx ; increment odd count
jmp cnt
even: inc dx ; increment even count
cnt: loop l0
mov ax, 0
hlt