# Constants

$.$data

MEMORY$\_$SIZE: $.$word $4096$ # Total memory size

CHUNK$\_$SIZE: $.$word $32$ # Size of each memory chunk

NUM$\_$CHUNKS: $.$word $128$ # Total number of chunks

MEMORY$\_$POOL: $.$space $4096$ # Memory pool

msg$1$: $.$asciiz $"$

Enter Size of Variable: $"$

msg$3$: $.$asciiz "Enter operation to be performed $(1-$allocation,$2-$deallocate$)$: $"$

error$\_$msg: $.$asciiz $"$

Invalid input exitig the program."

result$1$: $.$asciiz "Memory alocated

$"$

result$2$: $.$asciiz "The memory along with the variable is now free

$"$

repeat: $.$asciiz $"$

Do you want to perform another calculation?

$($Enter y for yes or n for no$)$

$"$

char: $.$space $1$

# Error message

allocation$\_$failed$\_$msg: $.$asciiz "Memory allocation failed.

$"$

# Data section

allocated$\_$chunks: $.$space $128$ # Array to store allocation status of each chunk $(0$ for free, $1$ for allocated$)$

$.$text

# Allocation function

main:

again:

li $v$0,4$

la $a$0,$msg$3$

syscall

li $v$0,5$

syscall

move $t$2,$$v$0$

li $v$0,4$

la $a$0,$msg$1$

syscall

li $v$0,5$

syscall

move $t$0,$$v$0$ #$t$0=$ number$1$

beq $t$2,1,$allocate$\_$memory

beq $t$2,2,$deallocate$\_$memory

li $v$0,4$

la $a$0,$allocation$\_$failed$\_$msg

syscall

b exit

allocate$\_$memory:

# Load arguments from registers

lw $a$0,0($$sp$)$ # Load size requested

lw $t$0,$ CHUNK$\_$SIZE # Load chunk size

div $a$0,$ $t$0$ # Divide size by chunk size

mflo $t$1$ # Quotient contains number of chunks needed

# Traverse memory pool to find free space

li $t$2,0$ # Initialize loop counter

la $t$3,$ MEMORY$\_$POOL # Load address of memory pool

check$\_$consecutive:

add $t$6,$ $t$2,$ $t$5$ # Calculate address of current chunk

li $v$0,1$ # Print integer syscall code

move $a$0,$ $t$6$ # Value to print $($address in $t$6)$

syscall # Print the value

lw $t$7,$ allocated$\_$chunks$($$t$6)$ # Load allocation status of current chunk

li $v$0,1$ # Print integer syscall code

move $a$0,$ $t$7$ # Value to print $($value loaded in $t$7)$

syscall # Print the value

beq $t$7,0,$ found$\_$space # If chunk is free, continue checking

bge $t$5,$ $t$1,$ next$\_$chunk # If not enough free chunks found, go to next chunk

addi $t$5,$ $t$5,1$ # Increment counter

j check$\_$consecutive

find$\_$free$\_$chunk:

lw $t$4,$ allocated$\_$chunks$($$t$2)$ # Load allocation status of current chunk

beq $t$4,1,$ next$\_$chunk # If chunk is allocated, go to next chunk

# Check if enough consecutive chunks are available

li $t$5,0$ # Initialize counter for consecutive free chunks

found$\_$space:

# Mark consecutive chunks as allocated

move $t$8,$ $t$2$ # Store starting address of allocation

li $t$9,1$

# Set allocated status

allocate$\_$chunk$\_$loop:

sw $t$9,$ allocated$\_$chunks$($$t$8)$ # Mark chunk as allocated

addi $t$8,$ $t$8,1$ # Move to next chunk

addi $t$5,$ $t$5,-1$ # Decrement counter

bgtz $t$5,$ allocate$\_$chunk$\_$loop # Loop until all chunks are allocated

# Calculate and return address of allocated memory

mul $t$0,$ $t$0,$ $t$2$ # Calculate offset

la $v$0,$ MEMORY$\_$POOL # Base address of memory pool

add $v$0,$ $v$0,$ $t$0$ # Add offset

j end$\_$allocation

next$\_$chunk:

addi $t$2,$ $t$2,1$ # Move to next chunk

bne $t$2,$ $t$1,$ find$\_$free$\_$chunk # Loop until all chunks are checked

# Allocation failed, raise exception or handle error

j allocation$\_$failed

end$\_$allocation:

jr $ra # Return to calle

b next$1$

next$1$:

li $v$0,4$

la $a$0,$result$1$

syscall

# Deallocation function

deallocate$\_$memory:

# Load arguments from registers

lw $a$0,0($$sp$)$ # Load address of memory to deallocate

la $t$0,$ MEMORY$\_$POOL # Base address of memory pool

sub $t$1,$ $a$0,$ $t$0$ # Calculate offset from base address

lw $t$2,$ CHUNK$\_$SIZE # Load chunk size

div $t$1,$ $t$2$ # Divide offset by chunk size

mflo $t$3$ # Quotient contains index of chunk to deallocate

# Mark corresponding chunk as free

li $t$4,0$ # Set free status

sw $t$4,$ allocated$\_$chunks$($$t$3)$

jr $ra # Return to caller

b next$2$

b next$2$

next$2$:

li $v$0,4$

la $a$0,$result$2$

syscall

# Exception handling

allocation$\_$failed:

# Handle allocation failure $($e$.$g$.,$ raise exception or print error message$)$

li $v$0,4$ # Print string syscall

la $a$0,$ allocation$\_$failed$\_$msg # Load address of error message

syscall

# Terminate program

beq $v$0,$$t$1,$exit

li $v$0,10$ # Exit syscall

syscall

exit: