exodist / gsd Goto Github PK

An array type, Plays nice with dict.

XTRN pointer wrappers should not be necessary after the switch to PRM

The GC and the PRM are unrelated except that they both manage memory. These should be separated.

PRM started as part of Dict. It has been moved out and rewritten.

Dict needs to be updated to use PRM instead of its epoch system.

Some work was made to do this, but it is unfinsihed, if necessary revert the Structure/src/* to 20b220a which is before the rework started.

Things to do:

• Switch to PRM
• Do not attach the 'trash' structure to all the internal structures. Instead use 'destructor' functions with PRM. A different destructor by type, provided at disposal should do it.

Already partly started.

The list should be able to reference into a hash and vice-versa, so some shared internal structure.

• Lists are created with a specific length that never changes
• Once created items are appended to it until its end.
• References are never changed/removed, but the value they point at can change.
• list 'assignment' operation where values of one list are put into the references of another (extra items are ignored if lists are different sizes)
• way to create lists by combining other lists (do not change original lists). Perhaps since lists are immutable after completion this can be achieved by an extra ref: list -> lds -> items where lds is an array. Most lists have a 1-element array pointing to their items, but concatenated lists have multi-element arrays pointing at the lds array of the original lists. The lds structure would need to be reference counted.

Structures uses the older atomic builtins

A makefile is not enough

Tokenizer should recognize keywords, when encountered it should follow their patterns to continue parsing until the pattern end. Once the pattern ends the keyword will be run.

enum { ALPHA, DIGIT, SYMBOL, CONTROL, SPACE } chartype( uint8_t *string, size_t size );

A single place for the hashing algorithms to live.

Array that grows as necessary, play nice with dict

Need to finish the PRM tests.

Probably a good idea to add a concurrent stress test as well.

slurp all text from start until the type of character changes

Test the GC implementation.

Probably also a good idea to write a concurrent stress test.

There are a few places where the dictionary can spin, should add a yield callback in case people want to have it do something useful while waiting. GSD will use this.

Another idea might be to make operations that would yield return a yield/try again code instead... might be too much work.

SRefs and USRefs are reference counted, make sure it never bumps the count up from 0, that would be bad. Alternatively we can make it bump up from 0 thanks to PRM, but the destructor for said objects must be smart enough to abort destruction when the ref count is > 0. Because of the prm epochs free should never occur after refcount++.

Add a makefile and tests to the hashlib

Simple string-as-key dictionary with most of the setup/work done for you. Only constructor argument should be a free() function for when values have a 0 ref count.

• Reads string
• read space/boundary separated tokens (Boundary is transition between character type)
• return array of tokens
• split token array based on specific character-sequence