Back | Home | Next

ToDo

ANNA  K5

@

Home
Glossary
Objectives
Formalism
Morphology
Physiology
Connectors
Serialization
Traits
Methods
Claims
Relations
Dictionary
Core UML
Ring1 Apps
Tiger Server
Features
History
ToDo
Authors
API
Images
ToDo
DNA Declarations
Physiology RO
Real Time RO
ANNA as an Eco System RO
HMM Generator
ERP

 

 

1           ToDo Tuesday, May 12, 2009

1.1         Merge DICTIONARY into TYPE.

1.      TOKEN merges into AMORPHOUS. It implies that tokens and used blocks are indistinguishable. Implies that the TypeInfo.Vector lists them both the same. So far a dictionary couldn't delete tokens and therefore never shrunk the pointer vector. Used blocks on the other hand are constantly created and deleted. Used blocks are aggregated by type instances directly, whereas tokens relate to one another through indexes. Used blocks that have a non-zero TypeInfo.Index are tokens. The vector is therefore reserved to tokens and objects.

2.      TYPE::MemGrow interogates the index of a used block to distinguish tokens from used blocks. From an allocation's point of view objects, tokens, used blocks, and free blocks can coexist on the same heap.

3.      TOKEN has int DirectLinks, int BackLinks, short crc16, and SourceID. SorceID is used for relating laws to outer html files, and is really just a debug field for EDICT

4.      The methods, flags and options of DICTIONARY would merge into TYPE.

5.      A DICTIONARY is both a memory manager and a stream. A dictionary is in fact an indirect memory manager whose blocks point to the encoding stream.

1.2         Every TYPE and TRelation is a DICTIONARY

6.      Removing the DICTIONARY typemaster means changing the file system.

7.      Introduce the 32Bit field AMORPHOUS::DateTime with virtual getter and setter. The interface transfers 64Bit, high resolution date and time values. Each type stores its own format, depending on what each type deems the requirement for time accuracy to be.

8.      TypeInfo.Vector is not the same as the Containment Vector. Containment needs no tree structure. Coalescence ensures iteration. Each memory manager must have a containment vector field.

9.      The Containment Vector doesn't persist and may always be re-created by parsing the heap twice.

10.  A token may be turned into a node via a loading mechanism. Lines can be constructed only between nodes. A line cannot be created between a node and a token. The context of a node of reference consists of all other nodes that can be reached directly from the reference. A node has an active (loaded) context which is part of its full context. It follows that a node whose context has not been fully loaded is also a token. The partly loaded node would handle its underlying token until the load of its context is complete. At such time, the underlying token may be destroyed and its role fully assumed by the node. Upon a full load, the node ceases to handle the token and begins to handle the encoding stream directly.

11.  A node may be turned into a token via a storing mechanism.

 

2           ToDo Sunday, April 05, 2009

2.1         RPC

12.  Need to model the notion of a method. All VMT vectors as well as the DNA must be mapped in the design.

13.  Update the model to reflect the running code. Regenerate the system's code from the model. Update the model to reflect some of our latest thoughts.

14.  Absorb all of ANNA's code into the EXIT statements of the model.

15.  All object VMTs are replaced by the interceptor VMT (one) which normally routes straight to the normal VMT of the object.

16.  TYPE must have pointers for NormalVMT and Virtual Method Prototype Table.

17.  Method prototypes have the flTrace flag initially cleared. Once the flag is set, the method entry and exit will be logged with arguments adequately deconvolved.

18.  Threads should construct call trees as the system runs. The trees are object proxies to the method prototypes which have been called.

19.  The object proxies must be allocated in separate memory managers each belonging to one given thread.

20.  Load the core's MAP file and set the handle of all functions to the addresses specified in the map. A text-code correspondence is now possible.

21.  Need the TEXT constant, instance of a CODE class with the text from all functions in the system.

22.  Method prototypes must be embedded into the code.

23.  The data segment must be mapped entirely.

24.  RPC between two morphic cells is possible only if full symbolics are loaded.

25.  The thread local variable RunReason can take the following values: LOCAL_CALL, LOCAL_JUMP, CONSTRUCT, DESTRUCT,

a.       v=F(args) Local indirect call through the VMT

b.      JUMP F(args) is a JUMP to a method with a more generic prototype.

c.       CTR(&ALLOCATOR) TYPE*t=TYPE(args) constructs a class of type F over the specified allocator and returns a pointer to the instance.

d.      RET is a statement that breaks out of a function which fad been called in construction mode and without discarding the stack content. .

e.       CALL(&Connector,stack) v=F(args) is a call to execute function F on the remote machine indicated by the Connector. The current thread blocks until the remote system returns.

f.       FORK(stack size,priority) v=F(args) spawns a new thread that begins executing function F. The system should block as soon as the initiator returns to the scope where varible v was allocated.

g.      POST(thread) v=F(args) attaches a queue to the specified thread and coils the call to F over the thread's queue.

h.      SEND(handler) v=F(args) sends a message to a handler.

2.1.1        AMORPHOUS and STREAM

26.  AMORPHOUS must become STREAM. All objects are streams.

27.  Split the allocation into DESIGN+DATA just like with morphic DICTIONARY.

2.2         Flags and UNION

28.  Need the UNION flag of structures to become functional. Must so overlay bit fields over their backbone integer.

29.  Need flags and enums built into the design and brought for editing into TypeViewer.

30.  The type viewer must become the system's property editor.

31.  Extend the type viewer to expand on demand. The viewer constructs selection paths over the type master being inspected. Those selectors map over the instances of that type.

32.  Our own tree view controls derived from the schematic editor.

33.  Our own text editor.

34.  Multi-phase multi-layer rendering of schematics with cabling in one of the layers. Layers:

a.       Bitmap

b.      Automation with title, icons, scrollbars, hot-spots, indicators, buttons, etc.

c.       Fields

d.      Sub-types

e.       Methods

f.       Constants

g.      Background

 

2.3         General

35.  Search capabilities in the Memory Map viewer. Wider text/hex dump.

36.  Search capabilities in the debug logger.

37.  SelfTest must work on stored structures (un-mounted K5 disks).

38.  Rose loader leaves trash strings in memory.

39.  Constants of empty types must show in Type Viewer as hex and be comparable.

40.  TYPE currently uses the MaxSize field to mean SizeCache and speed-up size calculus by not iterating the type's relations. MaxSize however is inherited from NODE where it means the length of an embedded or an external constant. All morphic types should (are) able to instantiate external constants but only NODES can mark embedded (unbound) constants. Need to extend the concept of extra data to all types of the core. Any object should have a structured header either followed by an amorphous tail of data, or handling an external amorphous space.

41.  SelfTest must update the mosquito indicators on each re-entry. SelfTest must conduct fairly serious tests even when launched on a branch.

42.  A version of the SelfTest must be GUI based and be configured with flags, etc. and log the results into bins.

43.  Memory Manager Viewer must have a tile where blocks are plotted onto a chart along the x=blocksize per y=total block space. This chart would show the distribution of small and large blocks. Double-click onto the chart must locate the block into the map viewer.

44.  Memory Map Viewer must animate the Type Viewer wherever an object is clicked.

3           ToDO Wednesday, September 03, 2008

3.1         Enterprise Navigator

  1. Must start using a new look for the Enterprise Navigator.
  2. Got to go to Delphi.
  3. Need new controls to unify things.
  4. All input lines and combo boxes should become RTF controls with fonts and special formatting.
  5. Need a mixed mode of menu bar to contain controls other than menus.
  6. A new tree view control that has 4 possible regions: tree, grid, info and bar.
  7. Need the Office-like FileOpen extendable dialogue box.

3.2         The object editor

  1. Any object editor is a desktop where aspect editors may be launched, resized, closed, edited. Desktop can log-off with or without saving the object data. Editor has a start-bar that acts as the current tab. Aspect editors may run full screen, with or without title and frame, all, none or some. The desktop’s start bar has a tray with special controls such as gauges.

3.3         Change the file format

  1. Flags for every class
  2. Connectors instead of LINE

3.4         The object inspector merges with the Scope Browser.

All scope browsers can be inspectors.

3.5         Edict5

Must correct the new encoding scheme.

Must detect the double title in HTML and remove it.

Encode numerals differently?

Allow a text to be modified. When a text gets deleted, all words defined within it are moved to their next reference outside of the deleting text.

The new search and replace procedure becomes possible.

Encode special HTML as such.

With HTML documents up comes the matter of hyperlinks. These have to be resolved within the dictionary’s persistence. References may either be resolved or postponed. Need more dictionary types: image, link, etc. The Primary Learning System issues a WEB group over the encoding band. The group is a table of links to the related documents. WEB is a recursive construct. All HTML objects are special predefined words.

3.6         Gaius5

Have to use the Dictionary to store Name and Information strings.

Detect whether the loaded info is HTML or plain text. Render HTML by hand within the Concept Editor. Must render at least tables, bitmaps, and links.

3.7         The Schematic Editor

Must evolve the Schematic Editor to do the following:

  1. Segregate the drawing board away from the ToolBar and StatusBar areas which may or may not be mounted externally. The SE becomes a neat reusable component.
  2. Draw an enterprise as a tree. Our trees must also have an associated drawing grid. The columns may be resized.
  3. Each tree node of this tree may be tagged to show its information detail, which is a HTML like sequence. Might want to box this info in a scrollable region. Want this region to be resizeable. Show the content of a node as a diagram.
  4. Draw the hierarchical Concept in GAIUS.
  5. Draw tables.
  6. SE must allow in-place editing. Position an insertion cursor in the scaled graphics.
  7. Must improve the drawing speed. This can only be achieved with K4’s clipping engine.

 

4           Next Phase (Planned: Wednesday, March 24, 2004)

4.1         Urgent steps

  1. Correct the STREE Next/Prev confusion.
  2. Rename TYPE and TRelation to TYPE and RELATION.
  1. Stabile file system.

2.      The free methods that currently link the loaded model into the morphic backbone need to become methods of their respective classes.

  1. Embed the design information into the type library. The client code that loads a type library may then modify its resources and save the library.
  2. We want to begin to rescue test and demo structures.

4.2         Changing the file format

This must be done once, and for all the foreseeable reasons:

  1. Must change the file format and the serializor so that the file format is: {<Comment>}[<Object>]n{<Comment>} to store entire object collections, and not just one object. This requirement is driven by the Depth Limited Serialization process that needs to store trunk cones of the onion.

 

$z

4

5

6

1

2

3

marker

Comment

Header

Comment

BA

BAA

BAB

BB

BBA

BBB

B

BABA

BBAA

BBBA

A

C

N

AA

CA

  1. No more CLSIDs. Changing the current export path resolution to the mini-path concept. Must rethink the null pointer to mean a pointer to Core->Abstract->Type->Void or something like that.
  2. Must rethink the serializor so that it doesn't consume so much stack. Currently, the serializor flattens the cross-reference and recurses a level for each serialized item. The aim should be for the serializor to consume a logarithmic amount of stack that exactly follows the route from Core center to the outer onion shell specified by DLS. These changes will affect the order of serialization and, therefore, deeply the file format.
  3. Go to 3D. Enhance point to be (x,y,z). Might even want to try a 3D rendering of our own. This entails enhancing the DxD class to do 3D line drawing through the ZBuffer, draw triangles ourselves, rendering bitmaps by hand. We need this to demonstrate the correctness of the 3D file-system.
  4. True color, and colors as vectors
  5. Flags and Options for each type of object.
  6. Any changes to the serializor order, such as the possible draw of wires on behalf (as children) of the endpoint node, which would correspond to the general flow of the text serializor.
  7. Adding a user extension field.
  8. Going to RPC would triple all pointers.
  9. Should think to some extent the requirements of the security system and allow fields into the base object for it.
  10. NODE must allow for future use in GUIs: they may need the following fields: Alignment (none, left, right, top, bottom, client), Anchors( left, right, top, bottom). Border style and width, Shadow size and offset. This is visual information that should be grouped together into a structure.
  11. NODE must also have a bendpoint list, so re-alignment needs to be done between LINE and NODE to have more in common.
  12. Bend point is 3D and has flags. Each bendpoint has a pointer to a NODE that needs to follow the bendpoint. Each bendpoint has a user field for general use. Bendpoints are editable with the LINE editor.
  13. OBJECT starts the debug/trace/profile interface. It supplies fields for them. We will need to have the same debug & trace fields of ANNA K4. We need a 64bit value for the "Time From Startup" measured in atomic CPU ticks, but convertible into time. This is the Last Accessed value for the object. We need the LastWritten value, and the Creation time. Need the global Step and maybe the Written count. This profiling data seems expensive and weighs at least 40 bytes.
  14. LINE needs to become CONNECTOR and generalize.
  15. TYPE adds the Alias field that stores a name chosen by a user. The GUI will try to expose this name rather than that which was designed. It is the equivalent of "Caption" for visual controls.
  16. Should include a max cardinal for types (Cardinality of relations, Index of Selectos, promoted to NODE).
  17. An OBJECT::flShortName flag to say that the instance has a built-in short name. When the flag is set, the object uses the Name and Info fields concatenated for an 8 char name. This is preferred as it doesn't rely on another memory allocation technique, and it also streams nicer.

4.3         The Scope View needs to be abstracted to the level of BASE

  1. The Scope View uses Proxy nodes that are real-time safe. The current proxies are interested in intercepting all kinds of core methods belonging to types along different hierarchies. We need to stop that. The abstract Scope Viewer should do everything the Enterprise Navigator currently does, and if more intercepting is required, one would need to specialize the Scope Viewer and refine a cluster of doubly descending proxies.
  2. Should overload the drawing of the tree and get it to also draw the grid.
  3. Need to rethink the header control and its interaction with the tree viewer.
  4. Enhance the TIsNodeClient with a list of instances that get configured from a multiple combo box. The list of instances is expanded as values by the tree control.

The main functions of the Scope View are:

  1. Load a structure from a Type Library.
  2. Expand/collapse proxies
  3. Create/delete proxy nodes
  4. Drag/Drop proxy nodes
  5. Multiple select proxy nodes
  6. Invoke/Revoke the specialized type viewer for a node
  7. Cut, Copy, and Paste proxies
  8. Other functions

4.4         The Command Interpreter

Must use a DOS-like command vocabulary:

ATTRIB

Displays or changes node attributes

CD <path>

Displays the name of or changes the current directory.

CHKDSK

Checks the integrity of the Enterprise

CLS

Clears the screen

COMP

Compares two files or directories

COPY

Copies one node to another

DEL

Deletes the current node

DIR

Lists the content of a directory

EXIT

Exits the command interpreter

FIND

Searches for something

MD,MKDIR

makes a simple scope

MOVE

Moves one node to another node.

TYPE

Is an interface to the viewer associated with the node

REN(AME)

Renames a node

VER

Reports the core version

  1. The console must be re-routable/installable.
  2. The command vocabulary is extensible.
  3. Command interpreter is a class that registers with the DEBUG_BASE.
  4. Must have built-in tests
  5. Must provide an interface for configuring the debug logger.
  6. Should configure the system's daemons.
  7. Once the design information is in, the command interpreter may configure any calls upon the Core.
  8. As soon as the first call becomes possible, the issue of storing and reusing scripts arrises.

4.5         The Model Loader

Must change the serializor to use Unions as grammars. The grammar parameter is logically obsolete. All Rose loaders must be re-shaped.

Extensions are required to load any UML construct.

Design of the Core may then proceed in UML.

4.6         Compilers

Be able to generate the text of the current node into the Schematic Editor using the old serialization method for text.

Click a button of the Semantic Editor to compile the script back into the Core and replace the original.

If the RTF comes from MS WORD and has headings, then create one class per heading, and information loaded from Normal text.

Use this method to automatically load legal text into the morphic backbone. See this in conjunction with the Generator of documentation.

Use a sub-compiler to look for underline text and add/match it to the existing type repository.

4.7         Generators

First, we want a text script in some flavour of our own language. We want text, so that work and thoughts on the Semantic Editor may commence.

It may also be possible to create an application of the Core that spins a morphic structure in HELP format, responds to WinHelp commands, and also allows the user to edit the structure. (The preferred way)

The HELP generally displays user information. In edit mode it allows the designer to configure the visibility level of all public nodes between "public" and "user", rename the nodes and retype the descriptions. We, therefore, need one more enum in the Visibility field of OBJECT to mark the vsUser. We also need to introduce the notion of ALIAS names for objects, that differs from the designed name.

4.8         Extend the Type Viewer

The Type Viewer is too simple at the moment.

Should be another utilisation of the Scope View, allowing expand/collapse of contained structures.

Instance data is formatted and collected in a window buffer from the core. Using ANNA K4 here for comparison.

The Type Viewer needs format information to work.

4.9         Schematic Editor

  1. Schematic Editor has a read-only mode.
  2. The schematic editor is a BCB component or a Frame that is reusable.
  3. The Schematic Editor can work without the tool-bar.
  4. The toolbars are forms docking into the rebar control. They may be undocked. When undocked, an editor expands to a different layout of a higher detail level.
  5. Must be able to re-connect a line's endpoint to another node.
  6. Wires go to dialer control pins.
  7. Dialer control should be more reliable.
  8. Subwires should not draw to relations whose recursion depth is 0.
  9. When the size of a node falls to 16 pixel height, a bitmap is preferred to the actual drawing. Might use the Justify flags to show the node's name. This move would produce nicer looking diagrams.
  10. A new schematic editing feature must be implemented to automatically clone types and automatically absorb them: A type that is deemed to be "Under-Development" cannot be null and it allows new relations. When a type that's under development looses its last relation, it also disappears. A type that's not under development is reluctant to change, and an attempt to add a relation to it will result in the creation of a descendent type that gets that relation. The auto-created type is deemed to be under-development until the user tags it off.

4.10     THREAD and STREAM

  1. A thread can step. A thread can auto-step (run) until stopped.
  2. A thread leaves a trail of activity which we call the history. This is a STREAM.
  3. A thread evolves towards a goal. Role.
  4. Rethink and introduce the Semantic Editor’s Reduction Head List as the goal and history maintenance method.
  5. Q: is THREAD a special relation that instantiates STREAMs?

 

4.11     Miscellaneous

  1. Find ways to declare __thread data under Linux.
  2. Repair TRuntime
  3. Repair the evaluator
  4. Rethink Selectors versus Proxies.
  5. Formalism and Morphology should become one document. Thorough rework.
  6. There must be no free types. All types should be bound by relations. Difficult to achieve in C++ constructors.
  7. Have to start thinking of templates.
  8. Discuss the Onion in the Concept Report.

 

 

 

 

1           ToDo (31 Aug 2005)

1.1         Type Master Editors

  1. Every type is editable
  2. Every type master instates an editor for objects of the given type
  3. Unions are edited by a choice of editors from the union members.
  4. UNION denotes a choice.

2           A new GUI

With major applications in the concept view at the centre.

2.1         GAIUS is an abstract frame

Each panel is a docking station.

Gaius is a multi relation.

GAIUS is recursive.

Left/Right IO browsers are Scope Browsers.

The Generic User Interface is Top VCenter Bottom, VCenter is Left, HCenter, Right.

The Generic User Interface construct is recursive and may be instantiated in any panel.

Only the topmost frame has a menu, log and may host the global toolbar.

The global toolbar is built at runtime.

The global frame saves/loads its settings from the INI file.

Page controls may turn to scroll windows and vice-versa. Tiling and cascading is possible within a scroll window.

The centre, left and right concept editor frame is special. Scope browsers behave differently when dropped into L or R, IO panels or at the centre.

2.2         Scope Browser

Scope browser would point to a toolbar, rather than contain one.

Scope browsers would share the same toolbar.

Tree viewer must become a specialization of the Canvas stream.

An Enterprise scope might be serialized as a tree. The information blocks can either be viewed as text or as image.

Need to be able to expand the Info of any node within the tree and achieve the same effect as Word with its headings. Porting the canvas to Linux would mean porting all the important components of the Navigator.

Every scope view can have the spreadsheet for details attached.

2.3         Schematic Editor

Would point to a toolbar rather than contain one.

An application would collect all the toolbars at the top.

2.4         The information panel of Gaius5

Must enhance the XRef capabilities. The base and derived concepts will create hotspots in the information text. Hyperlinks are established with hidden RTF text items.

The generator must have the option of adding a section of references at the end of each information block. The IO relationships listed in this paragraph may contain one or more blocks of indirect information that pertain to the referenced objects. These blocks must also be compiled through the reverse logic.

The principle at work here is that of structural morphism, which allows one scope S to induce a structural change C into a scope L. In other words, scope C inserts a new relation R into, or matches an existing relation R of, scope L and describes it on behalf of the endpoint scope C. The relation R is owned by L and used in C.

2.5         Use the code generator of Gaius5 to rescue old enterprises

Most important enterprises are with legislation. These need to be saved as text using the code generator of Gaius5.

2.6         Fix the ordering problems of the Serializor

The reordering of nodes after store/load is not acceptable.

2.7         Dictionary GUI

Repair the WordTable viewer based on STREE. This is a feature of any Type master. Sort the list. Add a filter control. Add a delete button. Add the Open button that creates a node into the scope with the info set.

3           Connectors drawn by their endpoint nodes

The line drawing algorithm must change so that wires are drawn in the context of their endpoints. This is paramount.

A cable draws in three steps which are enabled by corresponding flags:

  1. background drawing fills the cable with a colour
  2. sub-cable pass to draw each sub-wire, lables, etc.
  3. foreground drawing puts a lid over the casing of the cable.

The sub-wire loose-ends would draw as driven by the cable’s endpoint node.

Each wire needs to cache positions calculated during the cable draw.

The change is too complex to implement at both of a line’s ends so going to unary connectors would need to be done first. Doing that though will break the file-system compatibility.

4           CONNECTOR instead of LINE.

4.1         Shapes

A shape is a structure that describes position, size, and materials.

Shapes are recursive in that a shape may contain other shapes.

Shapes are simple trees.

The SShape structure inherits from STREE and adds SVisual and SMaterial.

A node contains a SVisual and SMaterial. A node’s scope together with visuals and materials is a shape.

Materials refer to Colour, elasticity, energy, filter, texture, etc. This may be a complex, growing structure.

Visuals include the vectors VOrigin and VSize.

Connectors also use shapes for their rails. Visual includes the linear length

SShape has a count and a pointer to a point list.

Each point in the list is a structure of:

  1. flags to describe the type of point
  2. position vector relative to the node’s centre.
  3. A bend point may be a sub-node. In this case the position vector is the sub-node’s position. The node pointer overlaps the position vector which is not used. Using sub-nodes as bend-points implies that each node destruction must be notified to the node’s parent who must update its point-list to exclude the deletion. A flag may state wether or not the node has contour sub-nodes.

4.2         Connector

A connector is a TREE followed by flags, count and a number of SShapes.

The connector is designed with one endpoint.

A degenerate connector is a TREE, therefore connector descends from it.

The Core would construct a number of connector types at initialisation.

Binary and ternary connectors ale VMT equivalent to unary connectors.

Connectors and Nodes are peer design elements and are therefore not comparable.

5           Introduce the clipping engine of K4 to speed-up the drawing of an enterprise.

A

B

S=D

C

D

E

Introduce Z dimension and draw a 3D picture.

6           Scenario, unions and layers

6.1         Scenarios

A scenario is a node S with children D and E who represents its youngest child D into scope A. Any node can toggle between being a scope or a scenario.

SE promotes D to the same level as S with respect to drawing and pick-correlation ops.

It derives that the high level archival system becomes possible.

The influence on GAIUS 5 may be that synonyms are bound to such a scenario node. Also, multi-lingual support may be handled this way.

To the semantics of the language Scenarios are Unions.

A scenario group is a set of objects out of which only one may be selected to represent the group. The scenario group tree is a special construct that impersonates the selected representing object. Must explain the notion of Object Variant within a scenario

6.2         Unions

All we know so far is that:

  1. unions are on pair with structures from a semantic point of view
  2. we need unions to implement grammars. A union is a list of choices that we call productions. A grammar is a union of productions. A production is a structure that may aggregate structures or grammars.

6.3         Layers

A scope may be single layer or multi-layer.

A Layer is a logical grouping of sub nodes. A layer is nothing more than a node. A type that groups its relations in group nodes is layering these relations. A complex type may be worked on layer by layer, one layer at a time. The interconnections of nodes from different layers are cabled.

To support layers the Morphic Core must enhance its TYPE logic so that:

  1. any iterator looking for relations or constants descends into nodes.
  2. Just as selectors are invisible in the schematic, so are the cables between them.

Ctrl-G is a command to group the selection. Ungrouping the selection promotes all of a group’s children to its parent.

Groups are a recursive concept.

6.4         No object semaphores

Changes to the interlock to suspend the locking thread, and resume the highest priority unlocking thread. This move frees the OBJECT::Semaphore field making it available to the system as OBJECT::Handle.

Objects become streams.

Streams become static manipulators, essentially disappearing from the model.

Threads may also vanish from the model.

6.5         Thread pause and resume

Conceive the core mechanism.

Add the GUI to do this.

Threads may need their own Type Editor to feature the progress indicator and cancel, pause, resume buttons.

The mini-toolbar of a type is a 16 pixel high bar that the scope browser may render in the grid. The mini-bar does not exist and is always rendered from an object’s state.

7           Serializing solid objects

Solid objects such as LINEs are the reason for

  1. reordering of scopes after serialization
  2. the enormous stack consumption.

Need to rethink this. See Concept Report “Portals between Morphic Systems”

A node N is of type T. N has a children C1... Cn. N is a scope and T is exactly a tree or more. Serializing N to persistence is the act of storing N’s information text, its children, and its data fields. N should not serialize its name.

Loading a file F into a node N is the act of overriding N’s type to that of F, overriding its name and information, and complementing N’s children with those loaded. Loading a node is therefore a MERGE.

The loading scope is properly bound to the enterprise and mounted right from the beginning of the serialization process. The Scope Browser needs not insert the loaded tree.

The serializor is very much like the compiler of Gaius.

7.1         Must re-instate the text generator and compiler

This work depends on the new policy of serializing connectors on behalf of their endpoint nodes. Must resolve drawing first.

Once the matter of drawing is resolved, the entire Serializor can be unified once again for File, Canvas, and Text.

7.2         The serializor is suited as the Evaluator

The serializor is essentially a top-down iterator that recurses into referenced sub-structures.

Right now, the serializor does not interlock canvas with nodes. The whole interlocking scheme must change so that the canvas thread blocks when it clashes with a disk or another serial process.

A lock is broken if the resource is destroyed while waited upon.

If a solid was locked then its subcomponents cannot be destroyed by another process even if they successfully locked the rails. It follows that a function needs to check against null pointers only for free-floating objects.

8           The morphic memory manager

8.1         The memory manager has two areas: heap and encoding

The heap area is the chain of free and used headers. These are either amorphous or object instances. The encoding is the series of constants generated by the managed objects.

The encoding is extraneous to the memory manager and accessible via a stream interface.

8.2         The re-link logic

STREE has a Relink function that looks-up all stree pointers and gets all referenced items to point back. OBJECT_BASE::Relink is a virtual method that extends this mechanism for all of an object’s tree aspects. The memory manager would call the Relink method after any re allocation.

8.3         Enterprises persist by storing their memory manager entirely

Critical here is the pointer re-base mechanism.

A MMM serializes by first persisting its TypeInfo vector. The vector is analogous to a relocation table.

8.4         Loading and storing morphic modules

Traditional loaders cannot do the opposite and store the latest state of a module

A morphic module is loaded by the BASE micro kernel.

A morphic module doesn’t link to any other module through the DLL mechanism

A morphic module may link to other morphic modules via interfaces.

The data segment of a morphic module is a memory manager.

The base micro kernel activates a morphic module after re-basing its memory manager.

The layout of a morphic module must be: signature, header, Relocation table, Code, Memory Manager.

A morphic module is portable across operating systems that implement the base micro kernel. Morphic modules can be shifted between windows and Linux.

A morphic module may contain 48-bit code.

8.5         Hardware support for morphic threads

Must gain Ring0 privileges of our K5 process. Failed to do that via exception handling. Could do it through DPMI. Could do it with a system driver.

The morphic core is then a system service. GUI is a Ring3 client attaching.

The BASE micro kernel might construct a table of segments and set it as the LDT of any thread forked thereafter. Far pointer indirections through this table may be virtualized.

8.6         RPC

ABSTRACT is a memory manager. Instances of ABSTRACT result in clones of the morphic cell. Objects allocated in this clone represent remote objects. The DNA of these proxy object is set to the RPC jump table.

Any method starts with a discriminator between PACK and DO. The PACK branch of any method serializes the arguments, whereas the DO branch executes the normal function code.

8.7         Must resolve the problems of the DICTIONARY.

Correct the word deletion logic. We must be able to extract a text from the dictionary.

Merge words.

The handle of a Memory Manager is a stream rather than a block of memory.

8.8         Must be able to cache streams in a smarter way.

STREAM::INIT or some other logic must allocate a memory structure to cache the file.

The cache must be smaller than the file.

The size of the file must be determined regardless of the size of the file.

The cache must have multiple regions to cover a file’s working areas.

A region’s minimum size must be determined.

The memory manager maintains two areas: heap and encoding. Since both are large, we want to cache them independently.

Most importantly is to cache the encoding. The legal database wouldn’t fit in RAM otherwise.

8.9         Promote the dictionary to TYPE

Any hierarchy can be a dictionary. Words may be of any type not just AMORPHOUS.

This involves creating and maintaining the STREE vector and indexes.

ProfileInfo data space is supplied by GUI. WordTable is Dictionary TypeInfo::Vector. Caches are allocated and resized based on PointerSize rather than FlatCount.

8.10     How do we view morphisms?

A morphism is a change inflicted over the encoding at multiple points. A sampling process cannot be expected to allocate dynamic buffers for those points.

The encoding map viewer would run once to draw each word. This is much like a decoding pass. To track changes the viewer needs to store a copy of the sampled region as reference. Sampling there-after is much like a difference pass.

8.11     File systems

Free-floating object instances are owned by their memory manager

Protected Memory Pool.

Accesses to PMP trigger the memory access violation exception.

Open handles are objects created in the local memory pool and handling remote objects.

9           Morphic Scopes

Need to employ the 32 depth levels of scoping made possible by the ENTER instruction.

A scope is used in another scope.

USES is a new type.

The use of a scope is a template instance.

A scope can be instantiated with two intents:

  1. to create an object of that scope as a type
  2. to create another type from that scope as a template.

A USES selector allows assignments to and from.

Assignments from a USES selector are simply use relations.

Assignments to a USES selector are template parameter substitutions.

Can be assigned only the external references of a USES type because the internal ones are satisfied.

USES is a device with inputs and outputs. Inputs are the unsatisfied types.

10       Structural changes

TForm is a TYPE descendent. Away with the TNullRelation.

Each control of K5 has a private menu and toolbar.

All controls of K5 share a unique master toolbar and menu

All controls of K5 share the same Locker object.

Scope Browser must be enhanced to allow multiple selections

10.1     Grouping

Should use TREE for abstract grouping of NODES and LINES

Must instruct the Scope Browser to flatten a tree

10.2     Filtering

10.3     Major objectives of Gaius 5

10.3.1    The disk synchronizer

Watches a directory structure much like the FAD of TFile

Filters files according to installable file system filters, as defined in the TFile hierarchy.

Generates an event whenever the following happens in the watched directory structure:

  1. a new file appears
  2. a file is deleted
  3. a file is moved
  4. a file changes content due to external factors

10.3.2    G:(OBJECT, TREE, TYPE) grammars

There is a correspondence between G and an Excel spreadsheet as follows:

  1. A TYPE corresponds to a sheet.
  2. Columns in a type sheet define the fields of that type.
  3. A row of a type define the instance of that type
  4. The pivot table is the TYPE of TYPES and has system defined columns.
  5. The rows of the TT table lists all instances of TYPE in the data set.

There is a correspondence between G and a database.

Must implement the Enterprise to Excel driver and the Enterprise to SQL driver.

10.3.3    Load/store XML files of legislation

Must build the first level XML parser in the BASE module

The XML parser builds a Grammar of OBJECT, TREE, and TYPE

The Enterprise to XML conversion driver:

  1. TYPES go to a schema
  2. Other instances go to XML files
  3. The entire data set is described by a master XML file of an embedded definition.

10.3.4    The code editor

Must have a time-line DLS control and associated logic

New nodes may be inserted between revisions

Colored delta in the info panel

Annotations at the bottom of the node comment

Using UML-like syntax for references

When a structure contains another all the inherited information should be brought into the descendent.

B-->A means that B specializes A. If A associates to other objects, then the associations may be selected and therefore included in B.

The code editor generates a fully formatted RTF document that can be turned into a HLP file.

The master scope browser goes to the centre panel for picking related notions and dropping them left and right of the current (obscured) panel.

The Schematic Editor also goes there.

L&R IO browsers allow for multiple selections. Accordingly, the L&R info editors load the union of these information fields.

Info viewers are configurable to show line info and/or endpoint info.

10.3.5    Any Scope Browser has a filter

Drag and drop operations between two entire scope browsers is possible to XOR, OR, AND their content:

Unary NOT operations over a filtered browser content.

The Left/Right Concept browser is a docking station.

10.4     Date and time of objects

Must enhance the BASE_OBJECT with:

  1. Creation date and time
  2. Last modified date and time
  3. Last accessed date and time (for rating)

This reconstruction must be done once the structures can be persisted to XLS files or other formats.

10.5     Generalize the SWord concept

1.      Change the significance of STREE_BASE::Object and STREE_BASE::Children with respect to handles and flags. If Flags&0x80 is set then the block is a terminal and has no children. Such used blocks are said to be Words regardless of MMM

2.      Objects may have tails only if the memory manager can relocate them.

3.      Variable size objects (with tails) cannot be owned into solids.

4.      Must be able to delete text blocks from a dictionary.

10.6     Loaders of Enterprise

The current file format is the Serial Binary File good for streaming.

Must correct the SBF to not invert the children list.

Another file format is needed: the Relocatable Binary File.

The RBF format uses a top-down algorithm over a branch.

It dumps each node followed by its children using the text/canvas serialization descent logic.

It collects a list of imports and exports, and a list of relocations. It appends these lists to the end/top of the RBF.

It can backtrack to fix the imports/exports.

The algorithm would presumably consume less stack.

The algorithm loads/stores a memory map that may be “activated”.

The RBF may be driven by the Memory Manager to load/store an entire memory pool.

10.7     History, undo, redo

One major problem to be resolved: inter-object links change as the structure evolves. Need a way to track them.

When DLS is set to a time interval, the new objects will be inserted at the top limit of that interval, and before any of their descendents in time.

This is a way to alter the history of a structure.

History is a change in field values of objects

Operations on history are labelled and thought of as atomic revisions.

11       Need 3D

Must do the following:

11.1     ANNA K4 Win32 links to DxD driver

The DxD.DLL is the video driver of K5.

We need a GDI canvas for K4. The current console mode is nice, but insufficient to exercise the graphical interface of K4.

11.2     Enhance the Enterprise to 3D

Matrix gains one more dimension. The resulting system should seamlessly run 2D enterprises because matrix is never persistent.

Add Z to points with a #define switch. The resulting file system breaks compatibility.

11.3     Rework the SAP compiler

The old SAP compiler will be ported from Pascal to C++. It should be fairly small.

The compiler creates an enterprise. The resulting enterprise may be viewed in 2D.

11.4     Each finite element has a type master

SAP type masters are installable. A SAP type master library of a few editors is necessary. The GUI frame is passed to the type master library. Different editors can be created depending on the nature of the frame. A type library can override:

  1. the look and content of an editor depending on the type of the container
  2. the behavior of an editor with respect to a multiple selection
  3. the drawing of the object in the schematic.
  4. the evaluation of each object.

The Evaluator is a K5 system object configurable in generic terms.

An Enterprise might be traversed by more than one evaluator threads.

Evaluator threads lock their topology and interlock to protect the topology.

The Evaluate method of each type can be overloaded by functional morphisms.

With SAP there will be a set of finite elements that control the scene.

Need a joystick for roto-translation of the camera within the scene. Camera is therefore a finite element. Wind and snow are finite elements with associated type editors.

11.5     Connecting solid objects

Node, beam and shell are some finite elements of SAP.

We know what nodes are.

BEAM is a binary CONNECTOR or a LINE of the enterprise.

TRIANGLE is a ternary connector. The serializor must be able to draw connectors in this manner. A Tetrahedral is a quaternary non-planar connector.

The schematic of a building may differ from its 3D solid look. Might want to store the rx, ry, and rz, otherwise the Vertex distinct from the 2D x,y fields for the schematic.

Connectors need binding to other nodes or connectors. A connector may nest other nodes. The position of these nodes is relative to that of the line. Moving a connector moves all its children. Stretching a line involves the stretching algorithm for the connector. Deforming a triangle would re-distribute its sub-nodes.The SAP scene is a finite element that owns nodes. Each object in the scene may own nodes. A connector may be defined between the sub-nodes of two or more different objects.

11.6     Enhance the SAP language with the #include statement

A SAP superscript must include several others. A statement to override the world transform matrix before including another SAP module.

12       Scripts

S

{

            int;

            int maxTcardinality;

            A {};   // Type definition

            B {};   // Type definition

            A a;     // relation from S to A

            B b      // relation from S to B with body

            {

                        A ia;    // internal variable

                        void m  // this points to the b field of previous this

                        {

                                    int buflen;

                                    char buf;

                        implementation:

                                    if (!bufsz)

                                                return;

                                    printf(“%s”,buf);

                        }

            }

            T[maxTcardinality]

            {

                        B b;

            } t1,t2;

            T[2]l*T[3]r      // Introduces a binary relation of S from T to T.

            {

                        // this is a (ti,tj) pair subfield of the previous this

                        if (this.l==0||this.r==0)

                                    return;

            };

};

13       The common K4/K5 micro kernel

Need a functional K4 hardware abstraction. Must segregate Desktop, OS, and HAL.

The K5 base micro kernel must become compatible with the K4 uKernel.

The unified uKernel must feature a PE and a NE loader.

Morphic modules are loaded through this uKernel. The Linux version loads PE modules.

14       Representing multi-lateral relations

15       NODE-CONNECTOR-TYPE

Stream merges with OBJECT for reasons explained when discussing handles.

A connector is primarily a Scope (TREE). The connector's default position is the weight center of its endpoints. No size or color, and no shape. However, colour for lines would be really nice. Shape for connectors would be dotted line, etc. The origin could at least mean the label position. The size could mean a scaling factor for the connector's content. A connector needs a material. CONNECTOR and NODE could merge. Node is CONNECTOR0. If NODE becomes the common ancestor of the abstract core, then it merges with both OBJECT and TREE. TYPE is currently a NODE descendent. A relation is a type that owns a connector. The final vocabulary would then be:

1.      NODE (merging OBJECT, TREE, CONNECTOR, STREAM, and THREAD)

2.      TYPE descending from NODE

3.      RELATION descending from TYPE and adding a NODE.

16       Cable wire endpoints

A polygon finds its weight center recursively by decaying to triangles.

We have an algorithm for distributing n points into a triangle.

17       Make a BASEuKERNEL.SYS device driver to fork RING0 threads.

5.      The driver is a FILE_DEVICE_VIRTUAL_DISK to IoCreateDevice a name such as "BaseMicroKernel". The IOCTLs handled by this driver are IOCTL_CreateThread and IOCTL_ShareMemory.

6.      The Create Thread IO control passes a structure which is exactly the argument block of the user-mode API. The function returns a handle to the new thread. The new thread will be created at RING0 but in the user process.

7.      BASE.DLL will call this driver instead of CreateThread. The expected result is that base will fork RING0 threads in the Navigator process.

8.      One major question here with raising the IOPL is wether the user-mode debugger would still work.

9.      A RING0 thread would allow unrestricted access to the CPU.

10.  The driver might handle virtual memory accesses.

11.  The driver could add more GDT selectors at startup.

12.  The threads spawned in such a manner might have a usable LDT.

13.  These steps would lead towards a 48-bit system sub-architecture under NT.

 

ToDo Thursday, August 6, 2009

Need several fixes:

  1. (done) TYPE::MemGrow calls STREE::InsertBefore which in turn does a remove. Those should be silent operations or flagged as such. They should not call any proxy updates. Interlock must update proxies as before.

  2. (fixed) Kernel crashes again on shutdown. Containment is not set correctly and unbinding the kernel's lines recurses to delete the kernel again.
  3. (done) Click on TypeView's overlaps and gaps to disable the hugely expensive full scan of the kernel.
  4. Get TypeView to reload its content on drag and drop of an object from the browser. This is for viewing call frames.
  5. (done) Want object name recognition in our GetSize scanner.
  6. (done) Enhance the memory test to show the address of a degenerated amorphous header so we can trace it in the map viewer.
  7. (done) Get threads to construct their USE relations in their own memory space and not alter the memory layout of their environment.
  8. (done) Repair memory defragmentation while auto tracing is installed. Instances of relocating objects may not be created. OBJECT::INIT must fail the allocation request. This should prevent auto bind while LINE is relocating. Relocating with auto-trace crashes when GVF_Entry tries to use the handle of a method that is being relocated.

  9. (done) Must run defragmentation with auto-trace enabled all the way.
  10. SelfTest must run even when full auto-tracing is enabled.
  11. TYPE::GetCommonAncestor, like GetCommonParent should be limited in its ascent by the would be STREE::Orbit field.

  12. Must generalize the interlocking mechanism to any STREE aspect.

  13. Introduce the OBJECT_BASE::flEmbeddedName and corresponding logic to save 48 bytes of header space per object.

  14. Running the thread test with auto-trace corrupts a thread's stack and claims a stack overflow condition which isn't confirmed by the map viewer which also crashes. SelfTest on the thread shows an errant free block of 4M inside a stack of merely 1M. Must fix.
  15. Methods binding and TIV creation must be triggered from the ABSTRACT editor.
  16. There should be a TIV restoration path as well.
  17. Should be able to start a thread test in parallel with opening a model file.
  18. MorphismPath must become a field of THREAD so that each thread can trace its own morphisms.

 

Hit Counter Created on 05/20/2009 03:46:45 AM, modified on 05/20/2009 03:45:28 AM

Home

Home | Feedback | Contents | Search

Send mail to webmaster@ProximaCentauri.ro with questions or comments about this web site.
All principles and artwork exposed on this site or by our software products is our intellectual property. 
Copyright © 2006 Proxima Centauri Romania SRL. Last modified: 05/27/09