A2osX/SYS/KERNEL.S.MEM.txt

PR#3
PREFIX /A2OSX.BUILD
LOMEM $A00
INC 1
AUTO 6
*--------------------------------------
* !!!!!! DO NOT USE ZPPtrs !!!!!
*--------------------------------------
ZPMemMgrSPtr 	.EQ ZPMEMMGR			Pointer To Slot selected
ZPMemMgrTmp1	.EQ ZPMEMMGR+2
ZPMemMgrSrcPtr	.EQ ZPMEMMGR+4
ZPMemMgrDstPtr	.EQ ZPMEMMGR+6
*--------------------------------------
MemMgr.ReqSize 	.EQ ZPMEMMGR+8			store requested Size
MemMgr.ReqFlags	.EQ ZPMEMMGR+10			store requested Flags
*--------------------------------------
* TODO :
*  - Create a 256 bytes table
*    mapping hMem's to real memory blocks to help 
*    Garbage collector move blocks
*  - mem.ID=0 always used! useful to test if hMem=0
*--------------------------------------
*               PUBLIC
*/--------------------------------------
* # GetMem
* ## In: 
*  PUSHW = Size Requested
*  PUSHB = Options
*   S.MEM.F.INIT0 : init memory with 00
*   S.MEM.F.ALIGN : page aligned
* ## Out:
*  CC : success
*   YA = PTR to Mem
*	X = hMem
*  CS :
*   A = EC
*\--------------------------------------
K.GetMem		>PULLB MemMgr.ReqFlags	store requested flags
				and #S.MEM.F.AUX
				beq .1

				sta SETREADAUX			Aux Mem requested,switch to AUX
				sta SETWRITEAUX				
				
.1				>PULLAX					get requested size
				bit #$0F				16 bytes aligned ?
				beq .2					yes, request it	
				
				and #$F0				align on 16 bytes
				clc
				adc #$10
				bcc .2
				inx
				
.2				>STAX MemMgr.ReqSize
				jsr K.GetMem.I
				
				bit MemMgr.ReqFlags		S.MEM.F.AUX ?
				bpl .9
				
				sta CLRREADAUX
				sta CLRWRITEAUX
				
.9				rts				
*/--------------------------------------
* # GetMemYA
* ## In: 
*  Y,A = Size Requested
* ## Out:
*  CC : success
*   YA = PTR to Mem (Uninitialised)
*	X = hMem
*  CS :
*   A = EC
*\--------------------------------------
K.GetMem0YA		ldx #S.MEM.F.INIT0
				stx MemMgr.ReqFlags
				.HS 2C					bit abs
				
K.GetMemYA		stz MemMgr.ReqFlags
				sta MemMgr.ReqSize+1
				tya
				bit #$0F				16 bytes aligned ?
				beq .1					yes, request it	
				
				and #$F0				align on 16 bytes
				clc
				adc #$10
				bcc .1
				inc MemMgr.ReqSize+1
				
.1				sta MemMgr.ReqSize
				
K.GetMem.I		>LDYAI MemMgr.Table
				>STYA ZPMemMgrSPtr
				
				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 MemMgr.NextSlot
				lda (ZPMemMgrSPtr)		Get Flags
				bmi .4					in use ?
				
.2				lda MemMgr.ReqFlags		Found an empty slot
				and #S.MEM.F.ALIGN		is request needs a page align ?
				beq .3
				
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	get LO of PTR
				bne .4					not page-aligned
				
.3				ldy #S.MEM.LEN
				lda (ZPMemMgrSPtr),y	get LEN of this block
				cmp MemMgr.ReqSize		compare with requested size
				bne .4
				
				iny
				lda (ZPMemMgrSPtr),y
				cmp MemMgr.ReqSize+1
				beq .7					requested size matches slot size !!!
				
.4				cpx MemMgr.LastSlot		any other slot to check?
				bne .1					last one, create a new slot
				
*-------------- Create a New SLOT
				lda MemMgr.ReqFlags
				and #S.MEM.F.ALIGN		is request needs a page align ?
				beq .6
				
				lda MemMgr.Free			target PTR will be page aligned ?
				sec
				sbc MemMgr.ReqSize
				beq .6					yes, allocate
				
				tay						no, reserve a free slot to fill gap
				lda #0
				jsr MemMgr.AddSlot		X = new slot
				bcs .9
				
.6				>LDYA MemMgr.ReqSize
				jsr MemMgr.AddSlot		X = new slot
				bcs .9
				
*-------------- Reuse this SLOT
.7				lda MemMgr.ReqFlags		get requested flags
				ora #S.MEM.F.INUSE		mark as in use
				sta (ZPMemMgrSPtr)
				
				and #S.MEM.F.INIT0
				beq .8

				jsr MemMgr.Init0		X not modified
				
.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
				
				ldy #S.PS.PID
				lda (pPs),y
				ldy #S.MEM.OWNERPID
				sta (ZPMemMgrSPtr),y
				
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y
				pha
				iny
				lda (ZPMemMgrSPtr),y	A = HI PTR
				ply						Y = LO PTR	
				clc						X = Current hMem
				
.9				rts						
*--------------------------------------
* MemMgr.AddSlot
*  In:
*   Y,A = Requested size
*  Out: 
*--------------------------------------
MemMgr.AddSlot  >STYA ZPMemMgrTmp1		save req size
				ldx MemMgr.LastSlot		
				inx
				beq .99					> 255 ERR:OUT OF SLOT
				
				lda MemMgr.Free			Compute base PTR=FREE-REQ size
				sec
				sbc ZPMemMgrTmp1
				tay						save new MemMgr.Free LO
				lda MemMgr.Free+1
				sbc ZPMemMgrTmp1+1
				pha						save new MemMgr.Free HI				

				cpy MemMgr.LoMem
				sbc MemMgr.LoMem+1
				bcc .98					ERR out of mem

				jsr MemMgr.NextSlot		X,Y unmodified
				
				tya						get back MemMgr.Free LO
				
				ldy #S.MEM.PTR
				sta MemMgr.Free			set as system MemMgr.Free value
				sta (ZPMemMgrSPtr),y	store is as base address of new slot
				iny
				pla						get back MemMgr.Free HI
				sta MemMgr.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 MemMgr.LastSlot		mark this slot allocated
				clc
				rts
				
.98				pla						discard new MemMgr.Free HI
				lda #MemMgr.ERROOM
				sec
				rts
				
.99				lda #MemMgr.ERROOH
				sec
				rts	
*--------------------------------------
MemMgr.NextSlot	lda ZPMemMgrSPtr
				clc
				adc #S.MEM
				sta ZPMemMgrSPtr
				bcc .8
				inc ZPMemMgrSPtr+1
.8				rts								
*--------------------------------------
MemMgr.Init0	ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	ZPMemMgrSPtr already set
				sta .2+1
				iny
				lda (ZPMemMgrSPtr),y
				sta .2+2
				
				ldy #S.MEM.LEN			
				lda (ZPMemMgrSPtr),y
				eor #$ff
				pha
				
				iny
				lda (ZPMemMgrSPtr),y
				eor #$ff				a=not hi count			

				ply						y=not lo count
				
				phx
				ldx #0
				
.1				iny
				bne .2
				inc
				beq .8
				
.2				stz $ffff,x
				inx
				bne .1
				inc .2+2
				bne .1
				
.8				plx
				rts
*/--------------------------------------
* # FreeMemA
* ## In:
*  A = hMem To Free
* ## Out:
*  none.
*  (X,Y unmodified)
*\--------------------------------------
K.FreeMemA	    phy
				tay
				
				beq *					Slot=0, reserved by Kernel
				
				jsr K.GetMemByIDA		X unmodified
				lda (ZPMemMgrSPtr)
				bpl .9					In use ?
				
				ldy #S.MEM.REFCNT
				lda (ZPMemMgrSPtr),y	Get count of those referencing this hMem
				dec						only one left ?	
				sta (ZPMemMgrSPtr),y
				bne .8					no, must be a code segment loaded several times
				
				lda #0					mark this slot as free
				sta (ZPMemMgrSPtr)

				ldy #S.MEM.BIN
				lda (ZPMemMgrSPtr),y	Any BINPATH to discard ?		
				beq .1
				
				jsr K.GetMemByIDA		X unmodified
				lda (ZPMemMgrSPtr)
				bpl *					***MUST BE ALLOCATED***
				
				lda #0					mark BINPATH slot as free
				sta (ZPMemMgrSPtr)
				
.1				lda MemMgr.LastSlot
				beq .8
				
				jsr K.GetMemByIDA		X unmodified
				lda (ZPMemMgrSPtr)
				bmi .8
				
				ldy #S.MEM.LEN
				lda (ZPMemMgrSPtr),y	give back LEN bytes
				clc
				adc MemMgr.Free			to MemMgr.Free
				sta MemMgr.Free
				iny
				lda (ZPMemMgrSPtr),y
				adc MemMgr.Free+1
				sta MemMgr.Free+1
				
				dec	MemMgr.LastSlot		discard last slot	
				bne .1					no slot left, exit

.8				ply
				clc
				rts
*--------------------------------------				
.9				ply						discard	saved Y

				lda $D000
				sta .91+1
				bit RRAMWRAMBNK2
				bit RRAMWRAMBNK2		
				
				jsr PS.Select0
				jsr DevMgr.SYS.Control
				
				pla						Get PC and sub 2 for calling address
				sec
				sbc #2
				tay
				pla
				sbc #0

				>PUSHYA
				
				>LDYAI K.FreeMemA.ERR
				jsr K.CPrintFYA
				
.91				ldx #$ff				
				bit $C000,x
				bit $C000,x
				bra *
*--------------------------------------
K.FreeMemA.ERR	>CSTR "***MemMgr:Attempt to Free an already freed hMem at $%H"
*/--------------------------------------
* # GetMemPtrA
* ## In:
*  A = hMem
* ## Out:
*  Y,A = PTR to MemBlock
*  (X unmodified)
*\--------------------------------------
K.GetMemPtrA	jsr K.GetMemByIDA
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y
				pha
				iny
				lda (ZPMemMgrSPtr),y
				ply
				rts
*/--------------------------------------
* # GetMemByIDA
* ## In:
*  A = hMem
* ## Out:
*  Y,A = ZPMemMgrSPtr = PTR to S.MEM
*  X unmodified
*\--------------------------------------
* Optimized for :
* MemMgr.Table is page aligned at $1800
* S.MEM is 8 bytes
*--------------------------------------
				.DO MemMgr.Table=$1800
				.ELSE
				!!!!!WARNING!!!!!
				.FIN
				.DO S.MEM=8
				.ELSE
				!!!!!WARNING!!!!!
				.FIN
*--------------------------------------
K.GetMemByIDA	sta ZPMemMgrSPtr
				lda /MemMgr.Table/8
				asl ZPMemMgrSPtr
				rol
				asl ZPMemMgrSPtr
				rol
				asl ZPMemMgrSPtr
				rol
				sta ZPMemMgrSPtr+1
				ldy ZPMemMgrSPtr
				rts
*--------------------------------------
* OLD CODE
*--------------------------------------
*				stz ZPMemMgrSPtr+1
*				asl
*				rol ZPMemMgrSPtr+1
*				asl
*				rol ZPMemMgrSPtr+1
*				asl
*				rol ZPMemMgrSPtr+1
**				clc						IMPLICIT
*				adc #MemMgr.Table
*				tay
*				lda ZPMemMgrSPtr+1
*				adc /MemMgr.Table				
*				sty ZPMemMgrSPtr
*				sta ZPMemMgrSPtr+1
*				rts
*--------------------------------------
K.LoadStkObjYA
*--------------------------------------
K.GetStkObjA
*--------------------------------------
K.FreeStkObjA
*--------------------------------------
K.SetLoMem
				clc
				rts
*/--------------------------------------
* # GetMemStatYA
* ## In:
*  Y,A = 24 bytes buffer
* ## Out:
*  Buffer filled with memory stats
*\--------------------------------------
K.GetMemStatYA	>STYA ZPMemMgrDstPtr
				
				ldy #6
				
.1				lda MemMgr.Table,y
				sta (ZPMemMgrDstPtr),y
				dey
				bpl .1
				
				
				ldx #6
				ldy #14
				
				sta SETREADAUX
				
.2				lda MemMgr.Table,x
				sta (ZPMemMgrDstPtr),y
				dey
				dex
				bpl .2
				
				sta CLRREADAUX
				
				ldx #6
				ldy #22

.3				lda DevMgr.Stat,x
				sta (ZPMemMgrDstPtr),y
				dey
				dex
				bpl .3
				
				rts
*--------------------------------------
* In:
*	Y,A = BINPATH (PSTR)
* Out:
*	Y,A = ZPMemMgrSPtr = PTR to S.MEM
*   X = hMem
*--------------------------------------
MEM.GetMemByNameYA
				ldx MemMgr.LastSlot
				beq .9

				>STYA ZPMemMgrSrcPtr		SAVE BINPATH
				>LDYAI MemMgr.Table
				>STYA ZPMemMgrTmp1		

				ldx #0
				
.1				lda (ZPMemMgrTmp1)
				bpl .6					In Use?
				
				ldy #S.MEM.BIN			any BIN PATH in this slot?	
				lda (ZPMemMgrTmp1),y
				beq .6
				
				jsr K.GetMemPtrA		get pathname
				>STYA ZPMemMgrDstPtr
				
				lda (ZPMemMgrSrcPtr)
				cmp (ZPMemMgrDstPtr)
				bne .6

				tay
				
.2				lda (ZPMemMgrSrcPtr),y
				cmp (ZPMemMgrDstPtr),y
				bne .6
				dey
				bne .2
				
				>LDYA ZPMemMgrTmp1
				
				clc
				rts
				
.6				lda ZPMemMgrTmp1
				clc
				adc #S.MEM
				sta ZPMemMgrTmp1
				bcc .7
				inc ZPMemMgrTmp1+1
				
.7				inx
				cpx MemMgr.LastSlot
				bne .1
				
.9				sec
				rts
*--------------------------------------
MEM.GarbageCollector
				clc
				rts
*--------------------------------------
MAN
SAVE /A2OSX.SRC/SYS/KERNEL.S.MEM
LOAD /A2OSX.SRC/SYS/KERNEL.S
ASM