Next: , Up: Multinode Model   [Contents][Index]


4.1 Principle of Operation

Nodes produce actions by means of invocation of assembler instructions, which perform effective work, in an instruction execution environment. A schematic diagram of a multinode model implementation is represented in Figure 4.1. The implementation consists of an environment state identification engine, an instruction emitting engine, and the instruction execution environment.

The environment state identification engine guesses current state of a node specified by a node index received from the instruction execution environment. The node is a component of the instruction execution environment and can represent an entity in the external environment with which a system you develop interacts. In simple cases, when single-node models are used, a single node may correspond to the whole environment external to the system, which is why the engine is called the environment state identification engine. That engine sends guessed current node state to the instruction emitting engine. The latter engine emits an assembler instruction based on a node state received and a node index used when guessing that node state.

The instruction execution environment is set up by the developer according to a problem the multinode model has to solve. The main job of the instruction execution environment is handling invocation of assembler instructions, which identifiers are received from the instruction emitting engine. An invoked assembler instruction may change the value of the spur of a particular type accumulated by both engines and a node index sent to those engines, i.e. switch the node context. The invoked instruction returns an instruction outcome and possibly changes the contents of the segment of look-ahead signals. An identifier of the invoked instruction, the instruction outcome, and the segment of look-ahead signals are sent to the environment state identification engine and take part in guessing the next node state.

Guessing node states and choosing which assembler instructions to invoke are spur-driven processes. That is, for example, the goal of the operation of a multinode model could be to identify states of entities contained in the external environment and to perform assembler instructions to maximize the velocity of increment of spur received along with other input from those entities. The concept of a period of time necessary to perform an assembler instruction is applied to calculate the velocity of increment of spur. When executing an instruction, time tracked by both engines is incremented by that period (this is not shown in Figure 4.1). Nodes of a multinode model share common time and spur, so guessing current node state and choosing which instruction to invoke depend on successfulness in solving a problem by all nodes of the model.

Schematic diagram of model implementation

Figure 4.1: Schematic diagram of model implementation

An actor, which output signals biuniquely correspond to node (entity) states, represents the environment state identification engine.

A tuple, which consists of an index of a node state identified by the actor at the previous operation step and of a list of signal identifiers of fixed length, represents an action choice state of the actor. One element of that list conveys information on an instruction invoked at the previous operation step and its outcome returned. The list may also contain the segment of look-ahead signals. When multiple nodes are used, a node identifier is additionally included in the action choice state. Figure 4.2 represents the structure of action choice states of the actor. Current state is not part of action choice state, but is shown, because it is the next signal in the event history after action choice state signals.

Action choice states of environment state identification engine

Figure 4.2: Action choice states of environment state identification engine

The instruction emitting engine is implemented as an actor, which action choice state is represented by an index of node state. When multiple nodes are used, a node identifier is also included in the action choice state. Figure 4.3 represents the structure of action choice states of the actor. An output signal is not a part of action choice state, but is shown, because it is the next signal in the event history after action choice state signals.

Action choice states of instruction emitting engine

Figure 4.3: Action choice states of instruction emitting engine

The environment state identification engine normally uses an additional spur type that corresponds to the automatic spur, which is a measure of adequacy of a state model within the engine to a sequence of received signals. See Automatic Spur, for additional information.

A helpful feature of a multinode model is the ability to convert internal data stored in its engines to a representation in the form of an assembler program. One can think of such feature as an automatic synthesis of an assembler program that solves an assigned task.

The important thing, which should be realized by the developer, is that automatic synthesis of the assembler program may work only in a situation when there does exist a program with a steady state model that solves an assigned task. The steady state model is a state model in which states have predictable input from the instruction execution environment. The input is transmitted to the states in the form of node identifiers, instruction identifiers, instruction outcomes, and look-ahead signals.

The following concepts were introduced to make possible the automatic synthesis of assembler programs.

Instruction meta-class

Represents an instruction name, without taking into account optional instruction parameters that follow the instruction name after a whitespace character. The name of instruction meta-class is the name of instruction that does not include instruction parameters. Example:

move

This instruction meta-class might represent an instruction that moves an agent in the environment in specific direction. However, a movement direction is not included in the name of the instruction meta-class.

Instruction class

Represents an instruction name, optionally followed by instruction parameters. Distinct strings, where every string consists of an instruction name and normalized instruction parameters (see Setting the Instruction Parameters String, for a description of normalization rules), correspond to distinct instruction classes. Example:

move north

This instruction class might represent an instruction that moves an agent in the environment one step in the north direction.

An instruction class has a specific number of instruction outcomes that can be analyzed by the environment state identification engine after instruction invocation when determining a new node state and then making a decision, which instruction to execute next.

For example, instruction ‘move north’ and other movement instructions might return a bitmask of four bits (i.e. an integer number in the range 0 to 15) after performing the move. A bit of the bitmask equal to 0 might indicate that there is an obstacle in a corresponding direction, thus giving a piece of information to the agent about configuration of the environment. Depending on the implementation of the agent, it may be useful to return the special instruction outcome 16 if a movement instruction is invoked, but there is an obstacle in a corresponding direction, which disallows the move.

Instruction class set

Is a node class that represents a set of instruction classes and its properties. For example, instruction class set ‘walker’, which could be used to investigate the environment, might contain the following instruction classes:

move north
move east
move south
move west
Instruction instance

An instance of instruction class in an assembler program. For example, in assembler program fragment

        move north
        joe  14, return_back
        move north
        ...
return_back:
        move south
        ...

there are two instances of instruction class ‘move north’.


Next: , Up: Multinode Model   [Contents][Index]