Distinguish between swap reservation and occupation in "new core ..." printouts

Tidy up the actual_old_paras/actual_old_blocks stuff and make the test script include all the information used to calculate success values (for added checking)

Change all byte sizes to paras, BLOCK_SIZE to BLOCK_PARAS and so on, make core_block_mem/swap_block_mem use one int per simulated para not one uint8_t per byte

Simplify hashing function to eliminate wraparound carry and use of long long

Fix some defines and conditional compiles that got lost in the ifdef-generation

Turn things around so that swap is written from top down

Remove first/last transfer optimization, it will be done differently

Make victim_core_blocks be calculated on the fly, keep only victim_swap_blocks

Re-enable all diagnostic printfs

Remove support for INODE_SWAP, make PREALLOCATE_SWAP always, make PREALLOCATE_CORE when INDIRECT_CORE (have done this automatically, adds diff --ifdef scripts)

Add forgotten file

Implement binary format script (for use within kernel, where there's no scanf)

More printf and unnecessary header removal, improve preprocessed blank lines

Implement FUZIX build, reduces block sizes, simplifies hash function, fixes rassert issues

Remove all non-essential printfs (for code size reduction in FUZIX build)

Separate out block allocation bitmap stuff into a reuseable module block_pool.c

Rename pool_realloc() to pool_alloc() with a mode argument instead of ad-hoc schemes like sending an offset of INT_MIN or not filling in the move_up() routine

New combined routine that does all of pool_alloc(), pool_realloc(), pool_realloc_base() and does the best it can with whatever move()/move_up() routines found

Combine non-moveable with moveable pool, define both head->move and head->move_up to enable moveability, or just head->move for ordinary malloc-like behaviour

Back out change from commit f4338d0 to process_avail, as process_avail was already defined to include the indirect blocks so no need to estimate their removal

Move swap space tests into do_swap_out(), re-evaluate for each victim to be less conservative in the inode swap case (allow only 2 blocks for partial indirect)

Do proper computations about disk free space including possible direct and indirect blocks (should revisit to be less conservative in transfer sizes by estimating each victim separately so we don't need to allow for so many partial direct/indirect blocks upfront), get NDEBUG working again (doesn't fill core with 0xaa)

More strictly declare variables at start of function, for ack

Fix inode leak caused by the f_trunc() modifications

Optimize out the classic or moveable allocator when not needed

Fix several more minor bugs, add gen.sh which pre-runs the C preprocessor to generate 6 specialized versions of the code

Fix INDIRECT_CORE with INODE_SWAP combination

Commit a forgotten file

First cut at inode swapping, works, may have an inode leak somewhere

Expand out the swap_read()/swap_write() functions inline, since they were only called once, and they were supposed to be abstract but now the abstract part is done by core_to_swap_copy()/swap_to_core_copy() and the rest is well defined -- makes core.h/swap.h and core.c/swap.c identical again except for core<->swap

Change order of adjusting process_core_blocks/process_swap_blocks/victim_core_blocks/victim_swap_blocks to reduce computation

Move PREALLOCATE_CORE/PREALLOCATE_SWAP defines into the respective header files and define victim_core_size/victim_swap_size there, remove old victim_xxx_item

More optimal handling of incomplete last block in swap_read()/swap_write()

Fix a bug in undo successful process realloc, fix a bug in number of blocks to transfer for swap_read() and swap_write(), fix minor inconsistencies

Move core_block_mem and swap_block_mem into pool_test_run.c and make core/swap memory accessor functions abstract, make core/swap move do incomplete last block

Get rid of the DEDICATED_xxx() macros in favour of more optimal inline code

Get rid of the dedicated and per-process core/swap item, just use per-process

Implement partial transfer to/from swap for incomplete last block

Make swap reading/writing take bytes not blocks, allowing incomplete last block

Make only the active (bytewise not blockwise) portion of process be hashed

Make process hash init and verify be bytewise rather than blockwise

Simplify the calling convention of the hash init and verify routines

Move the hash generation and verification stuff into process_test_run.c

Change process.blocks to process.size, do rounding and shifting at each access

Change test script to refer to bytes, although everything still done in blocks

In process related stuff, change size to blocks and SIZE to BLOCKS

Implement further macros DEDICATED_CORE_BASE() and DEDICATED_SWAP_LIMIT() which know whether the underlying items get updated during swap or whether they are preallocated at process creation time, and take a correction factor to apply in the latter case (by macro, so the correction is not evaluated in the former case)

Implement higher level macros to access process->core_item vs process->pool_item, victim->core_item vs victim_core_item and so on (depends on configuration)

Remove some bogus assertions that don't work in preallocated modes, tidy up

Change direction of swap in/out to forward, so that core is read/written in deque fashion (when swapping out, pop off the base, when swapping in, push onto the base) whereas swap is read/written in file fashion (when swapping out, append to the limit, when swapping in, truncate the limit), allows a swap-to-inode mode

Add pool_realloc_base() and pool_realloc_base_moveable() to allow a region to be used like a deque, new space can be pushed onto and contents popped off start

Add inode test script

Add UCP from FUZIX, with modifications to isolate FS stuff into new fuzix_fs.c

Implement simulated BLOCK_SIZE, hash create and check simulated block contents

Make n_blocks the primary size and table_size only given if indirect (was the other way around, making block stuff use either table_size or n_blocks), fix bugs

Subroutinize the hashing initialization and verification, to avoid duplication

Print message like 'alloc NN NN true|false' and then perform the operation and then '... ok', so that we can see clearly what messages come from what operation

Remove the reservation of spare space from pool object, core and swap modules

Implement INDIRECT_CORE, fix calculations so that PREALLOCATE_CORE make sense

For direct swap, store data in swap_block_mem not swap_table_mem, also for core

Add INDIRECT_SWAP option

Insert table_ in most core.c / swap.c functions e.g. core_alloc() becomes core_table_alloc(), because there will soon be an allocator for random block storage

Implement MOVEABLE_CORE and MOVEABLE_SWAP compile time options

Fix a bug of requiring a certain amount of free swap, when swap is preallocated

Fix a bug of victim_core_size being used uninitialized without PREALLOCATE_CORE

Implement PREALLOCATE_CORE and PREALLOCATE_SWAP compile time options

Improve use of alloc()/realloc()/free() to remove allocs and reallocs of size 0

Tidy up debugging code

Replace core_item and swap_item in the process structure with just pool_item

Keep process and victim pool items in dedicated storage during swapping (should generate smaller code, also ensures a process has only one pool item at a time)

Don't track victim or in-swap processes in LRU list (should've thought of this)

Use process->size == -1 to mark free process not process->lru_item.prev == NULL

Reverse swap addressing, so that swap is allocated from top down, and copies between memory and swap always go forward with respect to the actual backing store

Combine in-core and in-swap LRU list, using global victim pointer to first swap

Make the current victim be stored at head of in-swap LRU list instead of tail of in-core LRU list, strengthen invariants about core and/or swap membership

Use #define to improve casting for lru_item vs process pointers

Change process_head/process_item to lru_head/lru_item which is more descriptive

Process test, it is based on the pool test but involves two pools, one representing core and the other representing swap, and a new command 'run' which moves the given process fully into core, using an LRU algorithm to boot out some others

Initial commit, seemingly correct malloc/realloc/free pool implementation, where the user supplies the control blocks (instead of them appearing at the start of an allocation), and existing allocations can be moved to make room as needed