338 lines
5.4 KiB
Ucode
338 lines
5.4 KiB
Ucode
#define LIST_START 0xE0
|
|
#define HASH_MASK 0b1111
|
|
|
|
// PM initial state
|
|
#data 0x00 0x70
|
|
#data 0x01 0x7c
|
|
#data 0x02 0x88
|
|
#data 0x03 0x94
|
|
#data 0x04 0xa0
|
|
#data 0x05 0xac
|
|
#data 0x06 0xb8
|
|
#data 0x07 0xc4
|
|
#data 0x08 0x10
|
|
#data 0x09 0x1c
|
|
#data 0x0a 0x28
|
|
#data 0x0b 0x34
|
|
#data 0x0c 0x40
|
|
#data 0x0d 0x4c
|
|
#data 0x0e 0x58
|
|
#data 0x0f 0x64
|
|
|
|
#data 0x10 0x10
|
|
#data 0x1c 0x1c
|
|
#data 0x28 0x28
|
|
#data 0x34 0x34
|
|
#data 0x40 0x40
|
|
#data 0x4c 0x4c
|
|
#data 0x58 0x58
|
|
#data 0x64 0x64
|
|
#data 0x70 0x70
|
|
#data 0x7c 0x7c
|
|
#data 0x88 0x88
|
|
#data 0x94 0x94
|
|
#data 0xa0 0xa0
|
|
#data 0xac 0xac
|
|
#data 0xb8 0xb8
|
|
#data 0xc4 0xc4
|
|
|
|
// TODO: Include register initial-state compiler directive (saves, like, 2 cycles max)
|
|
// Set PC to LIST_START
|
|
const LIST_START
|
|
mov ar pc
|
|
|
|
|
|
//// ---- START OF DANK SORT ---- ////
|
|
$DANK_SORT
|
|
|
|
mov pc asr
|
|
mov pc ir; incpc
|
|
mov pm ar
|
|
mov pc asr
|
|
mov pm hr
|
|
|
|
brl; mov hr gr
|
|
brl
|
|
brl
|
|
brl
|
|
and HASH_MASK
|
|
mov ar asr
|
|
mov pm ar; mov pm asr
|
|
mov ar pc; mvn ar
|
|
add 1
|
|
add pm
|
|
|
|
mov ar lc
|
|
|
|
mov pc ar
|
|
|
|
// Move
|
|
mov pm pc
|
|
incpc
|
|
mov pc pm
|
|
mov ar pc
|
|
|
|
|
|
// First insertion
|
|
$DANK_INSERT_FIRST_START
|
|
|
|
incpc; bls @DANK_INSERT_FIRST_END_BIGGEST
|
|
|
|
mov pc asr
|
|
mov pm ar
|
|
sub gr
|
|
adn gr; brn @DANK_INSERT_FIRST_BOTTOM
|
|
|
|
mov gr pm
|
|
|
|
$DANK_INSERT_FIRST_SHIFT
|
|
incpc; bls @DANK_INSERT_SECOND_START
|
|
mov pc asr
|
|
mov pm gr
|
|
mov ar pm
|
|
mov gr ar; declc
|
|
bra @DANK_INSERT_FIRST_SHIFT
|
|
|
|
$DANK_INSERT_FIRST_BOTTOM
|
|
declc; bra @DANK_INSERT_FIRST_START
|
|
|
|
$DANK_INSERT_FIRST_END_BIGGEST
|
|
mov pc asr
|
|
mov gr pm
|
|
|
|
$DANK_INSERT_SECOND_START
|
|
// Finalize hash in HR
|
|
mov hr ar
|
|
and HASH_MASK
|
|
mov ar asr
|
|
mov pm hr
|
|
mov pm asr
|
|
|
|
mov pm pc; mov pm ar
|
|
incpc; sub hr
|
|
mov pc pm
|
|
|
|
mov ar lc
|
|
|
|
mov hr pc
|
|
|
|
// Get the value we hashed
|
|
mov ir asr
|
|
mov pm gr
|
|
|
|
// Second insertion
|
|
$DANK_INSERT_SECOND_LOOP
|
|
incpc; bls @DANK_INSERT_SECOND_END_BIGGEST
|
|
|
|
mov pc asr
|
|
mov pm ar
|
|
sub gr
|
|
adn gr; brn @DANK_INSERT_SECOND_BOTTOM
|
|
|
|
mov gr pm
|
|
|
|
$DANK_INSERT_SECOND_SHIFT
|
|
incpc; bls @DANK_INSERT_SECOND_END_NUMLET
|
|
mov pc asr
|
|
mov pm gr
|
|
mov ar pm
|
|
mov gr ar; declc
|
|
bra @DANK_INSERT_SECOND_SHIFT
|
|
|
|
$DANK_INSERT_SECOND_BOTTOM
|
|
declc; bra @DANK_INSERT_SECOND_LOOP
|
|
|
|
$DANK_INSERT_SECOND_END_BIGGEST
|
|
mov pc asr
|
|
mov gr pm
|
|
|
|
$DANK_INSERT_SECOND_END_NUMLET
|
|
|
|
mov ir ar; mov ir pc
|
|
sub 0xFE
|
|
brz @BUCKET_SORT_END; incpc
|
|
bra @DANK_SORT; incpc
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//// ---- START OF NORMAL (TRASH) BUCKET SORT ---- ////
|
|
// Start of bucket sort loop
|
|
|
|
// $BUCKET_SORT_START
|
|
//
|
|
// // Dereference pc into AR and GR (data[pc_])
|
|
// mov pc asr
|
|
// mov pm ar; mov pm gr
|
|
//
|
|
// // Hash: rotate left by 7 and only keep bits 3-6 (inclusive)
|
|
// // This means we index on the highest 4 bits of the value
|
|
// // and we have 3 bits of leniency: bucket size of 8
|
|
// rol
|
|
// rol
|
|
// rol
|
|
// rol; mov pc ir
|
|
// and HASH_MASK
|
|
// mov ar asr
|
|
// mov pm hr
|
|
// mov pm asr
|
|
//
|
|
// mov pm pc; mov pm ar
|
|
// incpc; sub hr
|
|
// mov pc pm
|
|
//
|
|
// // Prepare for insertion sort here:
|
|
// // Compute length of bucket into LC
|
|
// mov ar lc
|
|
//
|
|
// // Save start index to PC (for fast dereferencing)
|
|
// mov hr pc
|
|
//
|
|
// // Start of nested insertion sort
|
|
// $INSERTION_SORT_LOOP_START
|
|
//
|
|
// // If LC is set, we've reached the end of the elements
|
|
// bls @INSERTION_SORT_END_BIGGEST
|
|
//
|
|
//
|
|
// // If(data[pc] < gr) continue;
|
|
// mov pc asr
|
|
// mov pm ar
|
|
// sub gr
|
|
// adn gr; brn @INSERTION_SORT_LOOP_BOTTOM
|
|
//
|
|
// // Insert and shift here
|
|
// mov gr pm
|
|
//
|
|
// // Just shift all the elements
|
|
// $INSERTION_SHIFT_LOOP
|
|
// bls @INSERTION_SORT_END_NOT_BIGGEST
|
|
// incpc
|
|
// mov pc asr
|
|
// mov pm gr
|
|
// mov ar pm
|
|
// mov gr ar; declc
|
|
// bra @INSERTION_SHIFT_LOOP
|
|
//
|
|
//
|
|
// $INSERTION_SORT_LOOP_BOTTOM
|
|
// declc; bra @INSERTION_SORT_LOOP_START
|
|
//
|
|
//
|
|
// // Jump here if gr wasn't inserted into list
|
|
// $INSERTION_SORT_END_BIGGEST
|
|
// mov pc asr
|
|
// mov gr pm
|
|
//
|
|
// // Jump here if we already inserted gr into list
|
|
// $INSERTION_SORT_END_NOT_BIGGEST
|
|
//
|
|
// //// ---- LOOP BOTTOM ---- ////
|
|
// // Check if we should continue
|
|
// mov ir pc; mov ir ar
|
|
// incpc
|
|
// sub 0xFF
|
|
// brz @BUCKET_SORT_END
|
|
// bra @BUCKET_SORT_START
|
|
$BUCKET_SORT_END
|
|
|
|
|
|
|
|
|
|
// PC is 0 here. Data is sorted smallest-to largest in memory: just spread out into buckets ;)
|
|
// Perform final merge here
|
|
|
|
// Set PC to write index
|
|
const 0xE0
|
|
mov ar pc
|
|
|
|
|
|
// ######## INSERTION ##########
|
|
|
|
// COPY NEGATIVE
|
|
|
|
// Initialize GR as bucket pointer and IR as element pointer
|
|
const 0x10
|
|
mov ar gr
|
|
|
|
// $LOOP_NEGATIVE
|
|
// // Dereference GR into IR and compute length
|
|
// mov gr asr
|
|
// mov pm ir; mov pm ar
|
|
//
|
|
// // Subtract start from end and save (the resultant length) into LC
|
|
// sub gr
|
|
// mov ar lc
|
|
//
|
|
// // Copy 0x78 to initial list (0xE0)
|
|
// $COPY_BUCKET_NEGATIVE
|
|
// bls @NEXT_BUCKET_NEGATIVE
|
|
//
|
|
// mov ir asr; mov ir ar
|
|
// mov pm hr
|
|
//
|
|
// add 1
|
|
// mov ar ir
|
|
//
|
|
// // Write value to be copied into write index (data[pc] = data[ir])
|
|
// mov pc asr
|
|
// mov hr pm; incpc; declc
|
|
// bra @COPY_BUCKET_NEGATIVE
|
|
// $NEXT_BUCKET_NEGATIVE
|
|
//
|
|
// mov gr ar
|
|
// add 0x0C // AR is one above the length, so sub 8.
|
|
// mov ar gr
|
|
// sub 0x70
|
|
// bnz @LOOP_NEGATIVE
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// COPY POSITIVE
|
|
|
|
$LOOP_POSITIVE
|
|
// Dereference GR into IR and compute length
|
|
mov gr asr
|
|
mov pm ar
|
|
|
|
// Subtract start from end and save (the resultant length) into LC
|
|
sub gr
|
|
mov ar lc
|
|
|
|
// Calcuate the first element of the array and store in IR
|
|
mov gr ar
|
|
add 1
|
|
mov ar ir
|
|
|
|
// Copy 0x78 to initial list (0xE0)
|
|
$COPY_BUCKET_POSITIVE
|
|
bls @NEXT_BUCKET_POSITIVE
|
|
|
|
mov ir asr; mov ir ar
|
|
mov pm hr
|
|
|
|
add 1
|
|
mov ar ir
|
|
|
|
// Write value to be copied into write index (data[pc] = data[ir])
|
|
mov pc asr
|
|
mov hr pm; incpc; declc
|
|
bra @COPY_BUCKET_POSITIVE
|
|
$NEXT_BUCKET_POSITIVE
|
|
|
|
mov gr ar
|
|
add 0x0C
|
|
mov ar gr
|
|
sub 0xD0
|
|
bnz @LOOP_POSITIVE
|
|
|
|
|
|
$BREAK
|
|
halt
|