A2osX/SYS/KERNEL.S.MEM.txt

NEW
  AUTO 3,1
*--------------------------------------
ZPMemMgrSPtr 	.EQ ZPMEMMGR			Pointer To Slot selected
ZPMemMgrTmp1	.EQ ZPMEMMGR+2
ZPMemMgrSize	.EQ ZPMEMMGR+4
MEM.ReqFlags	.EQ ZPMEMMGR+6			store requested Flags
MEM.BestSlot	.EQ ZPMEMMGR+7
MEM.BestScore	.EQ ZPMemMgrTmp1
*/--------------------------------------
* # Realloc
* ## C
* `void *realloc(short int hMem, int size);`
* ## ASM
* `>PUSHB hMem`
* `>PUSHW size`
* `>SYSCALL realloc`
* ## RETURN VALUE
*  YA = ptr
*  X = hMem
*\--------------------------------------
MEM.NewSize		.BS 2
*--------------------------------------
K.Realloc		>PULLW MEM.NewSize

				>PULLA					Src hMem
				tax
				
				jsr MEM.GetMemByID
				
				ldy #S.MEM.LEN
				lda (ZPMemMgrSPtr),y
				pha
				iny
				lda (ZPMemMgrSPtr),y
				ply

				jsr MEM.MoveToAux		x = Src hMem, YA = Old size
				bcs .99
				
				stx .7+1				Aux hMem
				
				>LDYA MEM.NewSize
				>STYA A2L				size for MoveSetupA1A2
				
				jsr K.getmem
				bcs .99
				
				stx .8+1				new main hMem to return
				>STYA A4L				Save MAIN Ptr

				lda .7+1
				sta SETREADAUX
				jsr MEM.SetA1A2			Setup AUX base & End Ptrs
				sta CLRREADAUX
				
				clc						Aux To Main
				jsr XMov
				
.7				lda #$ff				SELF MODIFIED
				>SYSCALL2 FreeStkObj
				
.8				lda #$ff				SELF MODIFIED
				tax						X = new hMem
				jmp k.GetMemPtr			YA = new ptr
				
.99				rts
*/--------------------------------------
* # GetMem
*  Y,A = Size Requested
* ## RETURN VALUE
*  CC : success
*   YA = PTR to Mem (Uninitialised)
*	X = hMem
*  CS :
*   A = EC
*\--------------------------------------
K.GetMem0		ldx #S.MEM.F.INIT0
				.HS 2C					BIT ABS
K.GetMem		ldx #0
MEM.GetMem.YAX	stx MEM.ReqFlags
				sta ZPMemMgrSize+1

				tya
				bit #K.MEM.ALIGN-1		aligned ?
				beq .10					yes, request it	

				and #K.MEM.nALIGNm1		align on boundary
				clc
				adc #K.MEM.ALIGN
				bcc .10

				inc ZPMemMgrSize+1

.10				sta ZPMemMgrSize
				>LDYAI Mem.Table
				>STYA ZPMemMgrSPtr
				stz MEM.BestSlot
				ldx #$ff
				stx MEM.BestScore
				stx MEM.BestScore+1
				ldx #0					Current slot=0
				bra .4					skip slot 0, Check if some free slot to reuse first

.1				inx						move to next slot
				jsr Mem.NextSlot
				lda (ZPMemMgrSPtr)		Get Flags
				bmi .4					in use ?

.2				lda MEM.ReqFlags		Found an empty slot
				bit #S.MEM.F.NOCROSS
				beq .21

				ldy ZPMemMgrSize+1		> 255, not applicable
				bne .22					Align to page if $100
				
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	get LO of PTR
				clc
				adc ZPMemMgrSize
				bcs .4					cross page boundary....
				
				lda MEM.ReqFlags		get back flags to test if match
				
.21				bit #S.MEM.F.ALIGN		is request needs a page align ?
				beq .3

.22				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	get LO of PTR
				bne .4					not page-aligned

.3				ldy #S.MEM.LEN
				sec
				lda (ZPMemMgrSPtr),y	get LEN of this block
				sbc ZPMemMgrSize		compare with requested size
				pha
				iny
				lda (ZPMemMgrSPtr),y
				sbc ZPMemMgrSize+1
				ply						Y,A = SlotLen - ReqSize
				bcc .4					req size > slot size

				cpy MEM.BestScore
				pha
				sbc MEM.BestScore+1
				pla
				bcs	.4					Delta is >= BestScore	
				bne .4					Delta is > 255...

				sty MEM.BestScore
				sta MEM.BestScore+1
				stx MEM.BestSlot
.4				cpx Mem.LastSlot		any other slot to check?
				bne .1					last one, create a new slot

				lda MEM.BestSlot
				beq .5
				tax
				jsr MEM.GetMemByID
				bra .7
*-------------- Create a New SLOT

.5				lda MEM.ReqFlags
				bit #S.MEM.F.NOCROSS
				beq .51

				lda ZPMemMgrSize+1		> 255, not applicable
				bne .52					Align to page if $100

				lda Mem.Free			target PTR will be in same page ?
				beq .6					Memfree is xx00, will be in same page
				cmp ZPMemMgrSize
				bcs .6					yes, allocate

				tay						no, reserve a free slot to fill gap
				lda #0
				jsr Mem.AddSlot			X = new slot
				bcs .9

				lda #S.MEM.F.NOCROSS	Make sure marked FREE
				sta (ZPMemMgrSPtr)
				bra .6
				
.51				bit #S.MEM.F.ALIGN		is request needs a page align ?
				beq .6

.52				lda Mem.Free			target PTR will be page aligned ?
				sec
				sbc ZPMemMgrSize
				beq .6					yes, allocate

				tay						no, reserve a free slot to fill gap
				lda #0
				jsr Mem.AddSlot			X = new slot
				bcs .9

				lda #S.MEM.F.ALIGN		Make sure marked FREE
				sta (ZPMemMgrSPtr)

.6				>LDYA ZPMemMgrSize
				jsr Mem.AddSlot			X = new slot
				bcs .9
*-------------- Reuse this SLOT

.7				lda MEM.ReqFlags		get requested flags
				ora #S.MEM.F.INUSE		mark as in use
				sta (ZPMemMgrSPtr)
				and #S.MEM.F.INIT0
				beq .8

				jsr MEM.Init0
				
.8				lda #0
				ldy #S.MEM.BIN
				sta (ZPMemMgrSPtr),y
				inc						Mark this slot used by one process
				ldy #S.MEM.REFCNT
				sta (ZPMemMgrSPtr),y

				lda RDREADAUX
				pha
				
				sta CLRREADAUX

				ldy #S.PS.PID
				lda (pPS),y
				
				ldy #S.MEM.OWNERPID
				sta (ZPMemMgrSPtr),y
				
				pla
				bpl .80
				
				sta SETREADAUX

.80				clc

				jmp MEM.GetMEMPTR
* A = HI PTR,Y = LO PTR,X = Current hMem
.9				rts
*--------------------------------------
* Mem.AddSlot
*  In:
*   Y,A = Requested size
*  Out: 
*--------------------------------------
Mem.AddSlot  	>STYA ZPMemMgrTmp1		save req size
				ldx Mem.LastSlot
				inx
				beq .99					> 255 ERR:OUT OF SLOT

				lda Mem.Free			Compute base PTR=FREE-REQ size
				sec
				sbc ZPMemMgrTmp1
				tay						save new Mem.Free LO
				lda Mem.Free+1
				sbc ZPMemMgrTmp1+1
				pha						save new Mem.Free HI
				cpy Mem.LoMem
				sbc Mem.LoMem+1
				bcc .98					ERR out of mem

				jsr Mem.NextSlot		X,Y unmodified
				tya						get back Mem.Free LO
				ldy #S.MEM.PTR
				sta Mem.Free			set as system Mem.Free value
				sta (ZPMemMgrSPtr),y	store it as base address of new slot
				iny
				pla						get back Mem.Free HI
				sta Mem.Free+1
				sta (ZPMemMgrSPtr),y

				iny
				lda ZPMemMgrTmp1		get requested size
				sta (ZPMemMgrSPtr),y	setup slot LEN
				iny	
				lda ZPMemMgrTmp1+1
				sta (ZPMemMgrSPtr),y

				stx Mem.LastSlot		mark this slot allocated
				clc
				rts
.98				pla						discard new Mem.Free HI

.99				lda #E.OOM
				sec
				rts	
*--------------------------------------
MEM.NextSlot	lda ZPMemMgrSPtr
				clc
				adc #S.MEM
				sta ZPMemMgrSPtr
				bcc .8

				inc ZPMemMgrSPtr+1

.8				rts
*--------------------------------------
MEM.Init0		phx
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	ZPMemMgrSPtr already set
				sta .12+1
				iny
				lda (ZPMemMgrSPtr),y
				sta .12+2
				lda ZPMemMgrSize
				eor #$ff
				tay						y=not lo count
				lda ZPMemMgrSize+1
				eor #$ff				a=not hi count			

				ldx #0

.11				iny
				bne .12

				inc
				beq .13

.12				stz $ffff,x
				inx
				bne .11

				inc .12+2
				bra .11

.13				plx
				rts
*/--------------------------------------
* # FreeMem
*  A = hMem To Free
* ## RETURN VALUE
*  none.
*  (X unmodified)
*\--------------------------------------
K.FreeMem.ERR	>PUSHWI .1
				
				tya						hMem n Y
				>PUSHA
*			>DEBUG	
				ldy #S.PS.PID
				lda (pPS),y
				>PUSHA
				>PUSHBI 2
				
				>SYSCALL2 printf

				lda #E.INVH
				sec
				rts

.1				.CZ "Free($%h),PID=%d\r\n"
*--------------------------------------
K.FreeMem	    tay
				beq K.FreeMem.ERR		Slot=0, reserved by Kernel

				cmp Mem.LastSlot
				bcc .10
				
				bne K.FreeMem.ERR

.10				jsr MEM.GetMemByID		X,Y unmodified
				lda (ZPMemMgrSPtr)		In use ?
				bpl K.FreeMem.ERR

				ldy #S.MEM.REFCNT
				lda (ZPMemMgrSPtr),y
				dec						only one left ?	
				sta (ZPMemMgrSPtr),y
				bne .8					no, must be a code segment loaded several times

				lda (ZPMemMgrSPtr)
				and #$7f				keep flags for memdump
				sta (ZPMemMgrSPtr)		Mark as FREE
				and #S.MEM.F.CODE		CS: Any BINPATH to discard ?
				beq .1

				ldy #S.MEM.BIN
				lda (ZPMemMgrSPtr),y
				jsr MEM.GetMemByID		X unmodified
*				lda (ZPMemMgrSPtr)
*				bpl *					***MUST BE ALLOCATED***
				lda #0					mark BINPATH slot as free
				sta (ZPMemMgrSPtr)
				
.1				lda Mem.LastSlot
				beq .8

				jsr MEM.GetMemByID		X unmodified
				lda (ZPMemMgrSPtr)
				bmi .8					used, exit

.2				dec	Mem.LastSlot		free! get previous....
				beq .80					empty list: go set Mem.Free=Mem.HiMem

				lda Mem.LastSlot
				jsr MEM.GetMemByID		X unmodified
				lda (ZPMemMgrSPtr)
				bpl .2					free again! loop

				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	set Mem.Free... 
				sta Mem.Free
				iny
				lda (ZPMemMgrSPtr),y
				sta Mem.Free+1

.8				clc
				rts

.80				>LDYA Mem.HiMem
				>STYA Mem.Free
				clc
				rts
*/--------------------------------------
* # GetMemPtr
* A = hMem
* ## RETURN VALUE
* Y,A = PTR to MemBlock
* (X unmodified)
*\--------------------------------------
* Optimized for :
* Mem.Table is page aligned at $800
* S.MEM is 8 bytes
*--------------------------------------
				.DO Mem.Table=$800
				.ELSE
				!!!!!WARNING!!!!!
				.FIN
				.DO S.MEM=8
				.ELSE
				!!!!!WARNING!!!!!
				.FIN
*--------------------------------------
K.GetMemPtr		jsr MEM.GetMemByID
MEM.GetMEMPTR	ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y
				pha
				iny
				lda (ZPMemMgrSPtr),y
				ply
				rts
*--------------------------------------
MEM.GetMemByID	sta ZPMemMgrSPtr
				lda /Mem.Table/8
				asl ZPMemMgrSPtr
				rol
				asl ZPMemMgrSPtr
				rol
				asl ZPMemMgrSPtr
				rol
				sta ZPMemMgrSPtr+1
				rts
*--------------------------------------
Mem.SetOwner	lda CORE.LastPSID
				.HS 2C					BIT ABS
Mem.SetOwnerPS0	lda #0	
				ldy #S.MEM.OWNERPID
				sta (ZPMemMgrSPtr),y
				rts
*--------------------------------------
Mem.IncRefCnt	ldy #S.MEM.REFCNT
				lda (ZPMemMgrSPtr),y
				inc
				sta (ZPMemMgrSPtr),y
				rts
*/--------------------------------------
* # NewStkObj
*  Y,A = Size Requested
* ## RETURN VALUE
*  CC : success
*   YA = PTR to Mem (Uninitialised)
*	X = hMem
*  CS :
*   A = EC
*\--------------------------------------
*/--------------------------------------
* # GetStkObjPtr
* ## ASM
* `lda hStkObj`
* `>SYSCALL GetStkObjPtr`
* ## RETURN VALUE
*\--------------------------------------
*/--------------------------------------
* # FreeStkObj
*  A = hMem To Free (AUX Memory)
* ## RETURN VALUE
*  none.
*  (X,Y unmodified)
*\--------------------------------------
*--------------------------------------
MEM.DupX		sta SETREADAUX
				sta SETWRITEAUX
				jsr MEM.Dup
				sta CLRREADAUX
				sta CLRWRITEAUX
				rts
*--------------------------------------
MEM.Dup			jsr K.GetMemPtr
				>STYA A1L
				
				ldy #S.MEM.LEN
				lda (ZPMemMgrSPtr),y
				pha
				eor #$ff
				sta A4L
				iny
				lda (ZPMemMgrSPtr),y
				eor #$ff
				sta A4L+1
				eor #$ff
				ply

MEM.DupA1LnA4L	jsr K.GetMem
				bcs MEM.Dup.RTS
				
				>STYA A2L
				
				ldy #0
				
.1				inc A4L
				bne .2
				inc A4L+1
				beq .8
	
.2				lda (A1L),y
				sta (A2L),y
				iny
				bne .1
				
				inc A1L+1
				inc A2L+1
				bra .1
				
.8				txa
*				clc
MEM.Dup.RTS		rts				
*--------------------------------------
MEM.CopyToMain	clc
				.HS B0					BCS
MEM.MoveToMain	sec
				ror .1+1
				stx .2+1				Save AUX hMem
				>STYA A2L				Save LEN to copy/move

				sta CLRREADAUX			Make sure MAIN !!!!
				sta CLRWRITEAUX
				jsr K.GetMem
				bcs MEM.Dup.RTS

				stx .8+1				Save MAIN hMem
				>STYA A4L				Save MAIN Ptr

				lda .2+1				Get AUX mem Ptr
				sta SETREADAUX
				jsr MEM.SetA1A2			Setup AUX base & End Ptrs
				sta CLRREADAUX

				clc						Aux To Main
				jsr XMov

.1				lda #$ff				SELF MODIFIED
				bpl .8					Copy : dont discard AUX mem

.2				lda #$ff				SELF MODIFIED
				>SYSCALL2 FreeStkObj	release AUX mem

.8				ldx #$ff				Returns MAIN hMem
				txa
				jmp K.GetMemPtr			Y,A = Ptr
*--------------------------------------
MEM.MoveToAux	stx .1+1				Save MAIN hMem
				>STYA A2L				Save LEN to move

				>SYSCALL2 NewStkObj
				bcs .9

				stx .8+1				Save AUX hMem
				>STYA A4L				Save AUX Ptr

				lda .1+1
				jsr MEM.SetA1A2			Setup MAIN base & End Ptrs

				sec						Main To Aux
				jsr XMov

.1				lda #$ff				SELF MODIFIED
				jsr K.FreeMem			release MAIN memory

.8				ldx #$ff				Returns AUX hMem
*				clc

.9				rts
*--------------------------------------
MEM.SetA1A2		jsr K.GetMemPtr

				>STYA A1L				Start Address
				pha
				tya
				clc
				adc A2L
				tay

				pla
				adc A2L+1
				sta A2L+1

				tya
				bne .1
				
				dec A2L+1
				
.1				dey
				sty A2L
				
				rts
*--------------------------------------
MAN
SAVE usr/src/sys/kernel.s.mem
LOAD usr/src/sys/kernel.s
ASM