List space

From Organic Design wiki
Revision as of 07:51, 25 May 2016 by Nad (talk | contribs) (Three keys)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

The Nodes are relatively high-level structures and at runtime within the peer-nodes they sit upon a more fundamental layer called list space in which the actual nodal change takes place in a peer.

List items

The project uses a very fundamental memory model based on binary sequences. The entire memory can be divided into groups of smaller sequences which can themselves each be referred to by a locally unique binary sequence. For example, a 16 megabyte section of RAM can be divided into two million 64-bit sequences. List-space uses blocks of binary as its local memory resource and divides the block up into smaller binary sequences called list items. Every list-item holds the same structure of content which is a sequence of three list-item-keys.

List item keys

Since binary can be treated as numbers, each of the two million sequences in the example above can itself be referred to, or addressed, by a unique binary sequence called a list-item-key. In the case of two million items, the list-item-keys are 21 bit sequences. In other words, a 16MB list-space is divided into two million list-items each formed from three 21-bit list-item-keys.

  • The slight inefficiency of wasting one out of every 64 bits is done because of increased efficiency gained from working with sizes which are powers of two.
  • Even an "empty" list-item containing only zero's is still considered to be composed of three list-item-keys all referring to the very first list-item in the list-space (the one that has a sequence of 21 zero's for its address).

Three keys

There are a number of ways that list-items can be linked together to form lists and binary-trees which are all constructed from this general "three-slot" data structure, such as stacks, queues and axes. List-space uses a generic loop linking system for handling what's in use and what's free, but the main functionality of list-space that is the foundation for Nodal Reduction is binary traversal.

Within each of the three keys common to all list-items, the first and second are used for binary traversal which allows list-item-keys to be used as associations (see node references for more details on this concept). The last key is context-specific and represents a value at the end of an association, but both the association-key and the association-value are list-item-keys -- references to other list-items.

List-space methods

List-space is an environment which offers a generic set of methods that can manipulate a space of list-items, each addressable by a binary list-item-key. Each list-item is composed of three list-item-keys. This simple model is rich enough to support many kinds of higher data structures such as stacks, queues, threads, loops and trees.

  • listInsert()
  • listRemove(subject)
  • listTraverse(subject, object)
  • listGetValue(subject)
  • listSetValue(subject, value)
  • listGetKeys(subject)

List space definition

To allow automated replication of list-space functionality in different environments, nodal organisations are defined to integrate with the program compilation resources. To make use of these nodal organisations, the list-space must be completely defined using the concepts available from within a node-space.

The list-space functions are designed to use only very generic operations. The highest level operations a list-space needs are as follows:

  • malloc - the ability to access an area of memory in the form of a sequence of items, which each have a fixed-ordered range of possible states, the most practical being 24- or 32-bit binary words, or in a high-level language, an array of integers.
  • reference - each item in the sequence can be referred to by exactly one of the possible states - i.e., a state can be interpreted as an item-reference.
  • change - states can be copied from one address to another.
  • binary operations - the ability to represent a state as a binary sequence and iterate through it. Interpretation of a state as an address is also based on representing state as binary. In both high- and low-level languages, this can be achieved with the standard binary operations such as AND, OR, XOR, <<, >>.

See also