Came up with a few 'interesting' preliminary ideas although it definitely needs more work.
function linkage table
Each function call is mapped to a function linkage table. This is a 16-byte record which contains some code and data:
;; assembly format, some d* macros define the offset of the given type dstruct dint32 flt_move ; the move instruction dint32 flt_branch ; the branch instruction dint16 flt_section ; section address (or index?) dint16 flt_offset ; instruction offset dint16 flt_reserved0 ; padding dint16 flt_next ; list of records in this section dend flt_sizeof
The move instruction loads the index of the function itself into scratch register r12 and then either branches to a function which loads the section that contains the code, or a function which handles the function call itself. The runtime manages this. Unfortunately due to nesting it can't just invoke the target function directly. The data is needed to implement the functionality.
section table
The section table is also 16 bytes long and keeps track of the current base address of the section
dstruct dint16 sc_base ; loaded base address or ~0 if not loaded dint16 sc_flt ; function list for this section dint16 sc_size ; code size dint16 sc_reserved0 dint16 sc_next ; LRU list dint16 sc_prev dint32 sc_code ; global code location dend sc_sizeof
section header
To avoid the need of an auxiliary sort required at garbage collection time, the sections loaded into memory also have a small header of 8 bytes (for alignment).
dstruct dint32 sh_section ; the section record this belongs to dint32 sh_size ; the size of the whole section + data dend sh_sizeof
Function calls, hit
If the section is loaded ("cache hit") flt_branch points to a function which bounces to the actual function call and more importantly makes sure the calling function is loaded in memory before returning to it, which is the tricky bit.
Approximate algorithm:
rsp = return stack pointer ssp = section pointer docall(function, lr) ; save return address and current section rsp.push((lr-ssp.sc_base)); rsp.push(ssp); ; get section and calc entry point ssp = function.flt_section entry = ssp.sc_base + function.flt_offset ; set rebound handler lr = docall_return ; call function goto entry docall_return() ; restore ssp ssp = rsp.pull(); ; if still here, return to it (possibly different location) if (ssp.sc_base) { lr = rsp.pull() + ssp.sc_base; goto lr; } ; must load in section load_section(ssp) ; return to it lr = rsp.pull() + ssp.sc_base; goto lr;
I think I have everything there. It's fairly straightforward if a little involved.
If the section is the same it could avoid most of the work but the linker wont generate such code unless the code uses function pointers. The function loaded by the stub (flt record) might just be an id (support 65K functions) or an address (i.e. all on-core functions).
I have a preliminary shot at it which adds about 22 cycles to each cross-section function call in the case the section is present.
Function calls, miss
If the section for the function is not loaded, then the branch will instead point to a stub which loads the section first before basically invoking docall() itself.
doload(function, lr) ; save return address and current section rsp.push((lr-ssp)); rsp.push(ssp); ; load in section ssp = function.flt_section load_section(ssp); ; calculate function entry entry = ssp.sc_base + function.flt_offset ; set rebound handler (same) lr = docall_return ; call function goto entry
load_section() is where the fun starts.
Cache management
So I thought of a couple of ways to manage the cache but settled on a solution which uses garbage collection and movable objects. This ensures every byte possible is available for function use and i'm pretty certain will take less code to implement.
This is where the sh struct comes in to play - the cache needs both an LRU ordered list and a memory-location ordered list and this is the easiest way to implement it.
Anyway i've written up a bit of C to test the idea and i'm pretty sure it's sound. It's fairly long but each step is simple. I'm using AmigOS/exec linked lists as they('re cool and) fit this type of problem well.
loader_ctx { list loaded; list unloaded; int alloc; int limit; void *code; } ctx; load_section(ssp) { needed = ctx.limit - ssp.sc_size - sizeof(sh); if (ctx.alloc > needed) { ; not enough room - garbage collect based on LRU order ; scan LRU ordered list for sections which still fit used = 0; wnode = ctx.loaded.head; nnode = wnode.next; while (nnode) { nused = wnode.sc_size + used + sizeof(sh); if (nused > needed) break; used = nused; wnode = nnode; nnode = nnode.next; } ; mark the rest as removed while (nnode) { wnode.sc_base = -1; ;; fix all entry points to "doload" unload_functions(wnode.sc_flt); wnode.remove(); ctx.unloaded.addhead(wnode); wnode = nnode; nnode = nnode.next; } ; compact anything left, in address order src = 0; dst = 0; while (dst < used) { sh = ctx.code + src; wnode = sh.sh_section; size = sh.sh_size; ; has been expunged, skip it if (wnode.sc_base == -1) { src += size; continue; } ; move if necessary if (src != dst) { memmove(ctx.code + dst, ctx.code + src, size); wnode.sc_base = dst + sizeof(sh); } src += size; dst += size; } } ; load in new section ;; create section header sh = ctx.code + ctx.alloc; sh.sh_section = ssp; sh.sh_size = ssp.size + sizeof(sh); ;; allocate section memory ssp.sc_base = ctx.alloc + sizeof(sh); ctx.alloc += ssp.size + sizeof(sh); ;; copy in code from global shared memory memcpy(ssp.sc_base, ssp.sc_code, ssp.sc_size); ;; fix all entry points to "docall" load_functions(ssp.sc_flt); ;; move to loaded list ssp.remove(); ctx.loaded.addhead(ssp); }
The last couple of lines could also be used at each function call to ensure the section LRU list is correct, which is probably worth the extra overhead. Because the LRU order is only used to decide what to expunge and the memory order is used for packing it doesn't seem to need to move functions very often - which is obviously desirable. It might look like a lot of code but considering this is all that is required in totality it isn't that much.
The functions load_functions() and unload_functions() just set a synthesised branch instruction in the function stubs as appropriate.
Worth it?
Dunno and It's quite a lot of work to try it out - all the code above basically needs to be in assembly language for various reasons. And the loader needs to create all the data-structures needed as well, which is the flt table, the section table, and the section blocks themselves. And ... there needs to be some more relocation stuff done if the sections use relative relocs (i.e. -mshort-calls) when they are loaded or moved - not that this is particularly onerous mind you.
AmigaOS exec Lists
The basic list operations for an exec list are always efficient but turn out to be particularly compact in epiphany code, if the object is guaranteed to be 8-byte aligned which it should be due to the abi.
For example, node.remove() is only 3 instructions:
; r0 = node pointer ldrd r2,[r0] ; n.next, n.prev str r2,[r3] ; n.prev.next = n.next str r3,[r2,#1] ; n.next.prev = n.prev
The good thing about exec lists is that they don't need the list header to remove a node due to some (possibly) modern-c-breaking address-aliasing tricks, but asm has no such problems.
list.addTail() is only 4 instructions if you choose your registers wisely (5 otherwise).
; r3 = list pointer ; r0 = node pointer ldr r2,[r3] ; l.head strd r2,[r0] ; n.next = l.head, n.prev = &l.head str r0,[r2,#1] ; l.head.prev = n str r0,[r3] ; l.head = n
By design, &l.head == l.
Unfortunately the list iteration trick of going through d0 loads (which set the cc codes directly) on m68K doesn't translate quite as nicely, but it's still better than using a container list and still only uses 2 registers for the loop:
; iterate whole list ; r2 = list header ldr r0,[r2] ; wnhead (work node) ldr r1,[r0] ; nn = wn.next (next node) sub r1,r1,0 ; while (nn) { beq 2f 1: ; r0 is node pointer and free to be removed from list/reused ; node pointer is also ones 'data' so doesn't need an additional de-reference mov r0,r1 ; wn = nn ldr r1,[r1] ; nn = nn.next sub r1,r1,0 bne 1b 2:
Again the implementation has a hidden bonus in that the working node can be removed and moved to another list or freed without changing the loop construct or requiring additional registers.
For comparison, the same operation using m68K (devpac syntax might be out, been 20 years):
; a0 = list pointer mov.l (a0),a1 ; wn = l.head (work node) mov.l (a1),d0 ; nn = wn.next (next node) beq.s 2f ; while (nn) { .loop: ; a1 is node pointer, free to be removed from list/reused mov.l d0,a1 ; wn = nn mov.l (a1),d0 ; nn = wn.next bne.s .loop 2:
See lists.c from puppybits for a C implementation.
No comments:
Post a Comment