Difference between revisions of "List space"
m |
m |
||
| Line 1: | Line 1: | ||
| − | |||
| − | |||
The Nodes are relatively high-level structures and at ''[[Wikipedia:Runtime|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. | The Nodes are relatively high-level structures and at ''[[Wikipedia:Runtime|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 = | + | == 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''. | 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 = | + | == 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''. | 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. | *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). | *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 = | + | == Three keys == |
There are a number of ways that ''list-items'' can be linked together to form lists and ''[[w:Binary Tree|binary-trees]]'' which are all constructed from this general "three-slot" data structure, such as [[stack]]s, [[queue]]s and [[axis|axes]]. ''List-space'' uses a generic [[loop]] linking system for handling whats in use and what's free, but the main functionality of ''list-space'' which is the foundations for [[Nodal Reduction]] is [[binary traversal details|binary traversal]]. | There are a number of ways that ''list-items'' can be linked together to form lists and ''[[w:Binary Tree|binary-trees]]'' which are all constructed from this general "three-slot" data structure, such as [[stack]]s, [[queue]]s and [[axis|axes]]. ''List-space'' uses a generic [[loop]] linking system for handling whats in use and what's free, but the main functionality of ''list-space'' which is the foundations for [[Nodal Reduction]] is [[binary traversal details|binary traversal]]. | ||
Within each of the three keys common to all ''list-items'', the first and second are used for [[binary traversal details|binary traversal]] which allows ''list-item-keys'' to be used as [[association]]s (see [[key-as-reference]] 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''. | Within each of the three keys common to all ''list-items'', the first and second are used for [[binary traversal details|binary traversal]] which allows ''list-item-keys'' to be used as [[association]]s (see [[key-as-reference]] 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 methods == |
''List-space'' is an environment which offers a generic set of methods which 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. | ''List-space'' is an environment which offers a generic set of methods which 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() | *listInsert() | ||
| Line 25: | Line 23: | ||
*listGetKeys(subject) | *listGetKeys(subject) | ||
| − | = See also = | + | == See also == |
*[[list-space.c]] ''- current implementation'' | *[[list-space.c]] ''- current implementation'' | ||
| + | [[Category:Nodal Concepts]]__NOTOC__ | ||
Revision as of 03:42, 30 August 2007
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 whats in use and what's free, but the main functionality of list-space which is the foundations 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 key-as-reference 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 which 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)
See also
- list-space.c - current implementation
