mirror of
https://github.com/SEPPDROID/Digital-Research-Source-Code.git
synced 2025-10-24 08:54:17 +00:00
284 lines
7.2 KiB
Plaintext
284 lines
7.2 KiB
Plaintext
|
||
;*****************************************************
|
||
;*
|
||
;* Memory Allocation Unit Routines
|
||
;*
|
||
;* Memory Allocation Unit
|
||
;* A Memory Allocation Unit is a contiguous
|
||
;* area of memory that is described by a MD.
|
||
;* At the beginning of this area is a Suballocation
|
||
;* table that describes areas within it that are
|
||
;* allocated or free
|
||
;*
|
||
;* +----+----+----+----+----+----+----+----+
|
||
;* MD | Link | Start | Length | Plist |
|
||
;* +----+----+----+----+----+----+----+----+
|
||
;*
|
||
;* Link - Link field for placing MAUs on Linked
|
||
;* lists
|
||
;* Start - Segment Address of the area covered
|
||
;* Length - Length of area
|
||
;* Plist - used for a linked list of partitions
|
||
;* that are included in this area.
|
||
;*
|
||
;* Suballocation Table
|
||
;* The m_start field is the segment
|
||
;* address of the suballocation table (offset 0).
|
||
;* The first entry of the table is special and
|
||
;* has the following format.
|
||
;*
|
||
;* +----+----+----+----+----+
|
||
;* SAT0 |ents| reserved |
|
||
;* +----+----+----+----+----+
|
||
;*
|
||
;* sat1_ents - number of SAT entries
|
||
;* not including SAT0
|
||
;* Subsequent entries have the following format
|
||
;*
|
||
;* +----+----+----+----+----+
|
||
;* SAT | Start | Length |nall|
|
||
;* +----+----+----+----+----+
|
||
;*
|
||
;* start - start address of this contiguous
|
||
;* piece of memory
|
||
;* length - of this piece of memory
|
||
;* nall - number of times allocated
|
||
;* 0 = free 2 = share
|
||
;*
|
||
;*****************************************************
|
||
|
||
sat_start equ word ptr 0
|
||
sat_length equ word ptr sat_start + word
|
||
sat_nall equ byte ptr sat_length + word
|
||
satlen equ sat_nall + byte
|
||
|
||
;==============
|
||
maualloc_entry: ; Alloc from MAU
|
||
;==============
|
||
; Allocate a piece of memory from an MAU
|
||
;
|
||
; input: BX = address of MAU
|
||
; DX = MPB in u_wrkseg
|
||
; mpb_start = abs addr (0 = any)
|
||
; mpb_min = minimum necessary
|
||
; mpb_max = maximum wanted
|
||
;
|
||
; output: BX = 0h if success
|
||
; 0ffffh if failure
|
||
; CX = Error Code
|
||
; mpb_start = start address
|
||
; mpb_min = mcb_max = length
|
||
|
||
push es ! mov es,u_wrkseg
|
||
|
||
; if absolute, see if within MAU
|
||
mov si,dx ! mov cx,es:mpb_start[si]
|
||
cmp cx,0 ! je maua_rel
|
||
mov ax,m_start[bx]
|
||
cmp cx,ax ! jb maua_err
|
||
add ax,m_length[bx]
|
||
cmp cx,ax ! jae maua_err
|
||
maua_rel:
|
||
mov ds,m_start[bx]
|
||
maua_start:
|
||
sub bx,bx ! mov dl,bl ;BX->SAT entry
|
||
;DL = SAT number
|
||
maua_nsat:
|
||
inc dl ! add bx,satlen
|
||
cmp dl,.0 ! ja maua_err ;?out of table entries?
|
||
cmp sat_start[bx],0 ! je maua_err ;?end of used table?
|
||
cmp sat_nall[bx],0 ! jne maua_nsat ;?already allocated?
|
||
mov cx,es:mpb_start[si]
|
||
cmp cx,0 ! je maua_nabs ;?abs req?
|
||
mov ax,sat_start[bx]
|
||
cmp cx,ax ! jb maua_nsat ;?in this area?
|
||
add ax,sat_length[bx]
|
||
cmp cx,ax ! jae maua_nsat
|
||
mov dl,.0
|
||
cmp cx,sat_start[bx] ! je maua_nabs ;?exact?
|
||
sub cx,sat_start[bx]
|
||
mov bx,cx ! call mau_split ;make exact
|
||
jmps maua_start
|
||
maua_err:
|
||
mov bx,0ffffh ! mov cx,e_no_memory
|
||
jmps maua_out
|
||
maua_nabs:
|
||
mov cx,es:mpb_min[si]
|
||
mov ax,sat_length[bx]
|
||
cmp cx,ax ! ja maua_nsat
|
||
mov cx,es:mpb_max[si]
|
||
cmp cx,ax ! jae maua_alloc
|
||
cmp sat_nall[bx],0 ! je maua_splitit
|
||
mov ax,es:mpb_flags[si]
|
||
and ax,mf_share ! jz maua_nsat
|
||
jmps maua_alloc
|
||
maua_splitit: push si ! call mau_split ! pop si
|
||
maua_alloc: mov ax,sat_length[bx]
|
||
mov es:mpb_min[si],ax
|
||
mov es:mpb_max[si],ax
|
||
mov ax,sat_start[bx]
|
||
mov es:mpb_start[si],ax
|
||
inc sat_nall[bx]
|
||
call mau_collapse
|
||
sub bx,bx ! mov cx,bx
|
||
jmps maua_out
|
||
maua_out:
|
||
mov ds,sysdat
|
||
pop es ! ret
|
||
|
||
;=============
|
||
maufree_entry: ; Free from MAU
|
||
;=============
|
||
; free SAT in given MAU
|
||
; input: DX = address of MAF in u_wrkseg
|
||
; output: CX = 0 if successful
|
||
; CX = 0ffffh on failure
|
||
; if CX = 0,
|
||
; BX = 0 if MAU still in use
|
||
; BX = 0ffffh if MAU is empty
|
||
; if CX = 0ffffh
|
||
; BX = 0ffffh
|
||
|
||
push es ! mov es,u_wrkseg
|
||
mov si,dx
|
||
mov bx,es:maf_mau[si]
|
||
mov ds,m_start[bx]
|
||
|
||
; ES:SI -> MAF
|
||
; DS: 0 -> SAT table
|
||
|
||
sub bx,bx ! mov cx,bx
|
||
mov dx,es:maf_sat[si]
|
||
|
||
; DS:BX -> current SAT
|
||
; CX = SAT entry number
|
||
; DX = MAF_SAT start
|
||
|
||
mauf_nsat:
|
||
add bx,satlen ! inc cx
|
||
cmp cx,.0 ! ja mauf_err
|
||
cmp dx,sat_start[bx] ! jne mauf_nsat
|
||
cmp dx,es:maf_start[si] ! je mauf_free
|
||
mov cx,es:maf_start[si]
|
||
mov ax,sat_start[bx]
|
||
add ax,sat_length[bx]
|
||
cmp ax,cx ! jb mauf_err
|
||
; must split this SAT
|
||
sub cx,dx ! call mau_split
|
||
sub cx,cx ! mov bx,cx ! jmps mauf_c
|
||
mauf_free: dec sat_nall[bx]
|
||
mauf_c: call mau_collapse ! jmps mauf_out
|
||
mauf_err:
|
||
mov bx,0ffffh ! mov cx,e_no_memory
|
||
mauf_out:
|
||
pop es ! mov ds,sysdat
|
||
ret
|
||
|
||
mau_split: ;split SAT into 2
|
||
;--------- -----------------
|
||
; new SAT element starting at split boundary
|
||
; with nall=0, old has same nall.
|
||
; input: BX = address of SAT element
|
||
; CX = length to split at
|
||
; output: BX = address of original SAT element
|
||
|
||
push bx ! push cx
|
||
add bx,satlen ! call mau_insert
|
||
cmp cx,0 ! pop cx
|
||
pop bx ! jne maus_err ;create hole if error
|
||
lea di,satlen[bx] ! mov dx,sat_length[bx]
|
||
sub dx,cx ! mov sat_length[di],dx
|
||
mov dx,cx ! add dx,sat_start[bx]
|
||
mov sat_start[di],dx ! mov sat_nall[di],0
|
||
maus_err:
|
||
mov sat_length[bx],cx
|
||
ret
|
||
|
||
mau_collapse: ;collapse adjacent unallocated SATs
|
||
;------------ -----------------------------------
|
||
; collapse adjacent unallocated SATs and holes in table
|
||
; if possible
|
||
; return: BX = 0 if not empty
|
||
; = 0ffffh if empty
|
||
; CX = 0
|
||
|
||
mov bp,0ffffh ;assume empty
|
||
sub bx,bx ! mov cx,bx
|
||
mov di,satlen
|
||
mauc_nsat:
|
||
inc cx
|
||
cmp cx,.0 ! jb mauc_notend
|
||
mauc_done: sub cx,cx ! mov bx,bp ! ret
|
||
mauc_notend:
|
||
add bx,satlen ! lea di,satlen[bx]
|
||
cmp sat_start[bx],0 ! je mauc_done
|
||
cmp sat_start[di],0 ! je mauc_done
|
||
cmp sat_nall[bx],0 ! jne mauc_notfree
|
||
;this SAT is free
|
||
mov ax,sat_start[bx] ! add ax,sat_length[bx]
|
||
cmp ax,sat_start[di] ! je mauc_fnohole
|
||
;followed by a hole
|
||
mov ax,sat_start[di] ! sub ax,sat_start[bx]
|
||
mov sat_length[bx],ax
|
||
mauc_fnohole:
|
||
;free SAT., no hole
|
||
cmp sat_nall[di],0 ! jne mauc_nsat
|
||
;followed by free SAT
|
||
mov ax,sat_length[di]
|
||
add sat_length[bx],ax
|
||
push bx ! push cx
|
||
mov bx,di ! call mau_release
|
||
pop cx ! pop bx
|
||
sub bx,satlen ! dec cx
|
||
jmp mauc_nsat
|
||
mauc_notfree:
|
||
;allocated SAT
|
||
sub bp,bp ;not empty
|
||
mov ax,sat_start[bx] ! add ax,sat_length[bx]
|
||
cmp ax,sat_start[di] ! je mauc_nsat
|
||
;followed by a hole
|
||
cmp sat_nall[di],0 ! je mauc_nfhole
|
||
;next SAT is allocated
|
||
push bx ! push cx
|
||
mov di,bx ! call mau_insert
|
||
pop cx ! pop bx
|
||
jmp mauc_nsat
|
||
mauc_nfhole: ;Alloc SAT, followed by hole
|
||
;next SAT is free
|
||
mov ax,sat_start[di] ! sub ax,sat_start[bx]
|
||
sub sat_start[di],ax ! add sat_length[di],ax
|
||
jmp mauc_nsat
|
||
|
||
mau_release:
|
||
;-----------
|
||
; input: BX = SAT to release
|
||
|
||
push es ! mov ax,ds ! mov es,ax
|
||
mov ax,satlen
|
||
mul byte ptr .0
|
||
push ax ! mov cx,ax ! sub cx,bx
|
||
mov di,bx ! add bx,satlen
|
||
mov si,bx ! rep movs al,al
|
||
pop bx ! mov sat_length[bx],0
|
||
mov sat_start[bx],0
|
||
mov sat_nall[bx],0
|
||
pop es ! ret
|
||
|
||
mau_insert:
|
||
;----------
|
||
; input: BX = SAT to place new SAT in front
|
||
; output: CX = 0 if successful
|
||
|
||
mov ax,satlen ! mul byte ptr .0
|
||
mov si,ax ! mov cx,0ffffh
|
||
cmp sat_start[si],0 ! jne maui_r
|
||
mov cx,si ! sub cx,bx
|
||
dec si ! lea di,satlen[si]
|
||
push es ! push ds ! pop es
|
||
std ! rep movsb ! cld
|
||
pop es ! sub cx,cx
|
||
mov sat_start[bx],cx
|
||
mov sat_length[bx],cx
|
||
mov sat_nall[bx],cl
|
||
maui_r: ret
|
||
|