360 lines
8.3 KiB
NASM
360 lines
8.3 KiB
NASM
|
;_ page.asm Wed May 24 1989 Modified by: Walter Bright */
|
|||
|
|
; Copyright (C) 1989 by Walter Bright
|
|||
|
|
; All rights reserved
|
|||
|
|
; Written by Walter Bright
|
|||
|
|
|
|||
|
|
include macros.asm
|
|||
|
|
|
|||
|
|
; Storage allocator
|
|||
|
|
|
|||
|
|
begcode page
|
|||
|
|
|
|||
|
|
c_public page_malloc,page_calloc,page_realloc,page_free
|
|||
|
|
|
|||
|
|
; The start of each page (set by page_initialize()) looks like:
|
|||
|
|
pagesize equ 0 ;total size of this page
|
|||
|
|
maxsize equ 2 ;max size of a free block in free list
|
|||
|
|
allocp equ 4 ;roving pointer for allocator
|
|||
|
|
bassize equ 6 ;size of first block (0 so it
|
|||
|
|
; is never allocated)
|
|||
|
|
baslnk equ 8 ;offset of next free block
|
|||
|
|
pageoverhead equ 10 ;# of bytes of bookkeeping
|
|||
|
|
|
|||
|
|
; A block in the free list consists of:
|
|||
|
|
; dw size of block in bytes (must be even) (including both words)
|
|||
|
|
; dw pointer to next block in list
|
|||
|
|
|
|||
|
|
; When it's allocated,
|
|||
|
|
; dw # of bytes in this block including this word
|
|||
|
|
; db... the bytes allocated
|
|||
|
|
|
|||
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|||
|
|
; Allocate a block of data and clear it.
|
|||
|
|
; Use:
|
|||
|
|
; unsigned page_calloc(void far *baseptr,unsigned size);
|
|||
|
|
; Returns:
|
|||
|
|
; offset of allocated data else 0
|
|||
|
|
|
|||
|
|
func page_calloc
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
push P+4[BP]
|
|||
|
|
push P+2[BP]
|
|||
|
|
push P[BP]
|
|||
|
|
callm page_malloc ;allocate a chunk
|
|||
|
|
mov SP,BP
|
|||
|
|
tst AX ;out of memory?
|
|||
|
|
jz C2 ;yes
|
|||
|
|
.save <DI>
|
|||
|
|
les DI,P[BP] ;ES:DI = baseptr
|
|||
|
|
add DI,AX ;offset to start of allocated memory
|
|||
|
|
mov DX,AX ;save offset of result
|
|||
|
|
mov CX,ES:-2[DI] ;# of bytes
|
|||
|
|
shr CX,1 ;# of words (including byte count)
|
|||
|
|
dec CX ;skip byte count
|
|||
|
|
clr AX
|
|||
|
|
rep stosw ;clear the memory
|
|||
|
|
mov AX,DX ;restore offset of result
|
|||
|
|
.restore <DI>
|
|||
|
|
C2:
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
c_endp page_calloc
|
|||
|
|
|
|||
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|||
|
|
; Allocate a block of data.
|
|||
|
|
; unsigned page_malloc(void far *baseptr,unsigned size);
|
|||
|
|
; Returns:
|
|||
|
|
; offset of allocated data else 0
|
|||
|
|
|
|||
|
|
func page_malloc
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
.save <SI,DI>
|
|||
|
|
push DS
|
|||
|
|
lds BX,P[BP] ;DS:BX = baseptr
|
|||
|
|
mov AX,P+4[BP] ;get size
|
|||
|
|
add AX,3 ;need another word for length info
|
|||
|
|
and AL,0FEh ;round up to nearest word
|
|||
|
|
.if AX b 4, allocerr ;can't allocate 0 bytes
|
|||
|
|
|
|||
|
|
; mov SI,allocp[BX] ;last item
|
|||
|
|
mov SI,baslnk[BX] ;last item
|
|||
|
|
mov CX,SI ;CX to save bytes
|
|||
|
|
jmps A2
|
|||
|
|
|
|||
|
|
A1: mov SI,DI
|
|||
|
|
.if SI e CX, allocerr ;wrapped around, didn't find any
|
|||
|
|
A2: mov DI,2[BX+SI] ;next item in list
|
|||
|
|
.if AX a [BX+DI], A1 ;not big enough
|
|||
|
|
|
|||
|
|
je A3 ;exactly big enough
|
|||
|
|
add AX,2 ;we'll need another 2 bytes
|
|||
|
|
.if AX e [BX+DI],A3 ;have to allocate an entire block
|
|||
|
|
sub AX,2
|
|||
|
|
|
|||
|
|
;Allocate from bottom of free block.
|
|||
|
|
; DI -> free block
|
|||
|
|
; SI -> previous free block
|
|||
|
|
; AX = # of bytes in allocated block
|
|||
|
|
add 2[BX+SI],AX ;link to new free block
|
|||
|
|
mov SI,2[BX+SI] ;pointer to new free block
|
|||
|
|
mov CX,[BX+DI] ;number of bytes in block we're splitting
|
|||
|
|
sub CX,AX ;CX = remaining bytes
|
|||
|
|
mov [BX+SI],CX ;# of bytes in this block
|
|||
|
|
mov [BX+DI],AX ;[DI] = # of bytes
|
|||
|
|
|
|||
|
|
A3: mov AX,2[BX+DI] ;AX = next free block
|
|||
|
|
mov 2[BX+SI],AX ;skip the DI entry in list
|
|||
|
|
mov allocp[BX],SI
|
|||
|
|
mov AX,DI
|
|||
|
|
add AX,2 ;pointer to area allocated (DI + 2)
|
|||
|
|
A6: mov word ptr maxsize[BX],0 ;recalculate size of largest available block
|
|||
|
|
pop DS
|
|||
|
|
.restore <DI,SI>
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
|
|||
|
|
allocerr:
|
|||
|
|
clr AX ;NULL
|
|||
|
|
jmp A6
|
|||
|
|
c_endp page_malloc
|
|||
|
|
|
|||
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|||
|
|
; Reallocate memory that was allocated by page_malloc() or page_calloc().
|
|||
|
|
; Use:
|
|||
|
|
; unsigned page_realloc(void far *baseptr,unsigned p, unsigned nbytes)
|
|||
|
|
; Returns:
|
|||
|
|
; 0 error
|
|||
|
|
; else offset of reallocated memory
|
|||
|
|
|
|||
|
|
func page_realloc
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
|
|||
|
|
mov AX,P+4+2[BP] ;AX = nbytes
|
|||
|
|
tst AX ;trying to realloc() to 0 size?
|
|||
|
|
jnz R6 ;no
|
|||
|
|
pop BP
|
|||
|
|
jmp near ptr page_free ;page_free(baseptr,p)
|
|||
|
|
|
|||
|
|
R6: ;If p is 0, this is just a page_malloc()
|
|||
|
|
mov BX,P+4[BP] ;BX = p
|
|||
|
|
tst BX ;is p NULL?
|
|||
|
|
jnz R5 ;no
|
|||
|
|
;function just like page_malloc(baseptr,nbytes)
|
|||
|
|
push AX
|
|||
|
|
push P+2[BP]
|
|||
|
|
push P[BP]
|
|||
|
|
callm page_malloc
|
|||
|
|
mov SP,BP
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
|
|||
|
|
;if realloced size is smaller, attempt to just shrink current block
|
|||
|
|
R5: push SI
|
|||
|
|
les SI,P[BP] ;ES:SI = baseptr
|
|||
|
|
sub BX,2
|
|||
|
|
mov CX,ES:[SI+BX] ;CX = # of bytes in this block
|
|||
|
|
add AX,3
|
|||
|
|
and AL,0FEh ;AX = real new size
|
|||
|
|
sub CX,AX
|
|||
|
|
jb R3 ;if allocating more bytes
|
|||
|
|
.if CX b 4, R4 ;size of free list entry
|
|||
|
|
mov ES:[SI+BX],AX ;realloced size of p
|
|||
|
|
add BX,AX ;BX -> new fragment
|
|||
|
|
mov ES:[SI+BX],CX ;size of new fragment
|
|||
|
|
add BX,2
|
|||
|
|
push BX
|
|||
|
|
push P+2[BP]
|
|||
|
|
push P[BP]
|
|||
|
|
callm page_free
|
|||
|
|
add SP,6
|
|||
|
|
R4:
|
|||
|
|
mov AX,P+4[BP]
|
|||
|
|
jmps R1 ;no change, return p
|
|||
|
|
|
|||
|
|
;we'll have to allocate a new block, copy the data over,
|
|||
|
|
;and free the old one
|
|||
|
|
R3:
|
|||
|
|
push P+6[BP]
|
|||
|
|
push P+2[BP]
|
|||
|
|
push P[BP]
|
|||
|
|
callm page_malloc ;page_malloc(baseptr,nbytes)
|
|||
|
|
add SP,6
|
|||
|
|
tst AX
|
|||
|
|
jz rallocerr ;error
|
|||
|
|
push AX ;save pointer to new memory
|
|||
|
|
.save <DI>
|
|||
|
|
push DS
|
|||
|
|
mov DI,AX
|
|||
|
|
add DI,SI ;ES:DI -> new item
|
|||
|
|
add SI,P+4[BP] ;DS:SI -> original
|
|||
|
|
mov CX,ES
|
|||
|
|
mov DS,CX
|
|||
|
|
mov CX,-2[SI]
|
|||
|
|
.if CX be -2[DI], R2
|
|||
|
|
mov CX,-2[DI] ;CX = smaller of two size
|
|||
|
|
R2: shr CX,1 ;# of words
|
|||
|
|
dec CX ;compensate for extra word in beginning
|
|||
|
|
rep movsw ;transfer the words
|
|||
|
|
pop DS
|
|||
|
|
push P+4[BP]
|
|||
|
|
push P+2[BP]
|
|||
|
|
push P[BP]
|
|||
|
|
callm page_free ;free the old one
|
|||
|
|
add SP,6
|
|||
|
|
.restore <DI>
|
|||
|
|
tst AX
|
|||
|
|
pop AX ;restore pointer to new memory
|
|||
|
|
jz R1
|
|||
|
|
rallocerr:
|
|||
|
|
clr AX
|
|||
|
|
R1: pop SI
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
c_endp page_realloc
|
|||
|
|
|
|||
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|||
|
|
; Free memory that was allocated by page_malloc() or page_calloc().
|
|||
|
|
; Use:
|
|||
|
|
; int page_free(void far *baseptr,unsigned p);
|
|||
|
|
; Returns:
|
|||
|
|
; 0 success
|
|||
|
|
; -1 error
|
|||
|
|
|
|||
|
|
func page_free
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
.save <SI,DI>
|
|||
|
|
push DS
|
|||
|
|
mov DX,P+4[BP] ;get p
|
|||
|
|
tst DX ;pass a NULL pointer?
|
|||
|
|
jz F5 ;yes, return 0
|
|||
|
|
lds BX,P[BP] ;DS:BX = baseptr
|
|||
|
|
.if DX be baslnk+1, freeerr ;if below bottom of pool
|
|||
|
|
.if DX ae pagesize[BX], freeerr ;if above top of pool
|
|||
|
|
test DL,1 ;odd?
|
|||
|
|
jne freeerr
|
|||
|
|
sub DX,2 ;point to start of block
|
|||
|
|
mov SI,DX
|
|||
|
|
mov AX,[BX+SI] ;# of bytes in block to be freed
|
|||
|
|
|
|||
|
|
; Try to find SI and DI such that SI < DX < DI
|
|||
|
|
|
|||
|
|
mov SI,allocp[BX] ;try our roving pointer
|
|||
|
|
.if SI b DX, F1 ;a good starting point
|
|||
|
|
mov SI, bassize
|
|||
|
|
jmps F1
|
|||
|
|
|
|||
|
|
F6: mov SI,DI
|
|||
|
|
F1: mov DI,2[BX+SI] ;the next in the list
|
|||
|
|
.if SI ae DX, freeerr
|
|||
|
|
.if DI a DX, F2 ;got it
|
|||
|
|
.if DI a SI, F6 ;no wrap around (SI < DI < DX)
|
|||
|
|
|
|||
|
|
; We have SI < DX < DI (relative position in list)
|
|||
|
|
|
|||
|
|
F2: mov CX,[BX+SI] ;# of bytes in previous block
|
|||
|
|
add CX,SI ;+ link
|
|||
|
|
.if CX ne DX, F3 ;if can't collapse with prev block
|
|||
|
|
add [BX+SI],AX
|
|||
|
|
jmps F4
|
|||
|
|
|
|||
|
|
F3: mov 2[BX+SI],DX ;link to DX
|
|||
|
|
mov SI,DX
|
|||
|
|
mov 2[BX+SI],DI ;link to block after DX
|
|||
|
|
|
|||
|
|
; See if we can collapse SI with DI
|
|||
|
|
; SI -> block just before DI
|
|||
|
|
; DI -> block just after SI
|
|||
|
|
|
|||
|
|
F4: mov allocp[BX],SI ;for next time
|
|||
|
|
mov AX,[BX+SI]
|
|||
|
|
add AX,SI
|
|||
|
|
.if AX ne DI, F5 ;nope
|
|||
|
|
mov AX,2[DI+BX] ;link after DI
|
|||
|
|
mov 2[SI+BX],AX ;becomes link after SI
|
|||
|
|
mov AX,[BX+DI] ;# of bytes in DI
|
|||
|
|
add [BX+SI],AX ;add to # of bytes in SI
|
|||
|
|
|
|||
|
|
F5: clr AX ;success
|
|||
|
|
F7: mov word ptr maxsize[BX],0 ;recalc max size
|
|||
|
|
pop DS
|
|||
|
|
.restore <DI,SI>
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
|
|||
|
|
freeerr:
|
|||
|
|
mov AX,-1 ;error
|
|||
|
|
jmp F7
|
|||
|
|
c_endp page_free
|
|||
|
|
|
|||
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|||
|
|
; Determine size of largest free block in page.
|
|||
|
|
; unsigned page_maxfree(void far *baseptr);
|
|||
|
|
|
|||
|
|
c_public page_maxfree
|
|||
|
|
func page_maxfree
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
push SI
|
|||
|
|
push DS
|
|||
|
|
lds SI,P[BP] ;DS:SI = baseptr
|
|||
|
|
mov AX,maxsize[SI]
|
|||
|
|
tst AX
|
|||
|
|
jnz M3 ;does not need recalculation
|
|||
|
|
clr AX
|
|||
|
|
mov BX,baslnk[SI] ;offset to first free block
|
|||
|
|
M1: mov CX,[SI+BX] ;size of free block
|
|||
|
|
.if CX b AX, M2
|
|||
|
|
mov AX,CX
|
|||
|
|
M2: mov CX,2[SI+BX] ;offset to next link
|
|||
|
|
xchg CX,BX
|
|||
|
|
.if BX a CX, M1
|
|||
|
|
sub AX,2
|
|||
|
|
jc M4
|
|||
|
|
mov maxsize[SI],AX
|
|||
|
|
M3: pop DS
|
|||
|
|
pop SI
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
|
|||
|
|
M4: clr AX
|
|||
|
|
jmp M3
|
|||
|
|
c_endp page_maxfree
|
|||
|
|
|
|||
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|||
|
|
; Initialize memory allocation system in a page.
|
|||
|
|
; unsigned page_initialize(void far *baseptr,unsigned pagesize);
|
|||
|
|
; Returns:
|
|||
|
|
; size of largest allocatable block
|
|||
|
|
|
|||
|
|
c_public page_initialize
|
|||
|
|
func page_initialize
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
push DS
|
|||
|
|
lds BX,P[BP] ;DS:BX = baseptr
|
|||
|
|
mov AX,P+4[BP] ;AX = pagesize
|
|||
|
|
mov pagesize[BX],AX
|
|||
|
|
sub AX,pageoverhead
|
|||
|
|
mov word ptr allocp[BX],bassize
|
|||
|
|
mov word ptr bassize[BX],0
|
|||
|
|
mov word ptr baslnk[BX],pageoverhead
|
|||
|
|
|
|||
|
|
;Construct one big free block of the remainder
|
|||
|
|
mov pageoverhead[BX],AX ;size of that block
|
|||
|
|
mov word ptr pageoverhead+2[BX],bassize
|
|||
|
|
|
|||
|
|
sub AX,2 ;overhead per allocated block
|
|||
|
|
mov maxsize[BX],AX
|
|||
|
|
|
|||
|
|
pop DS
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
c_endp page_initialize
|
|||
|
|
|
|||
|
|
endcode page
|
|||
|
|
end
|
|||
|
|
|