WO1998058312A1 - Composition of systems of objects by interlocking coordination, protection, and distribution - Google Patents
Composition of systems of objects by interlocking coordination, protection, and distribution Download PDFInfo
- Publication number
- WO1998058312A1 WO1998058312A1 PCT/US1997/010465 US9710465W WO9858312A1 WO 1998058312 A1 WO1998058312 A1 WO 1998058312A1 US 9710465 W US9710465 W US 9710465W WO 9858312 A1 WO9858312 A1 WO 9858312A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- objects
- interface
- cycle
- cycles
- data
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
Definitions
- This invention relates generally to the implementation of software systems and, more specifically, to a methodology for composing numerous individual systems into a composite system which exhibits the same operational properties and characteristics of the individual underlying systems.
- Hardware either a printed circuit board or an integrated circuit
- CAD Computer Aided Design
- a design is built by placing reusable components on a schematic diagram. These components typically are stored in a library of standard components.
- the library representation of each component includes a pictorial representation which depicts the component's external connections, and an executable behavioral model of the component.
- the entire composite schematic may be associated with a pictorial image, and a list of its ports which are available to other, outside components may be devised; both the image and list are stored into the component library as an entirely new component.
- This new component may now be called upon to create another, generally more complex schematic. This ability to "compose" multiple objects into a single object makes it both possible and practical to reuse hardware designs.
- a wire is both lossless and symmetric. Lossless means that signals are never discarded by the wire. Symmetric means that any signal applied at one end of the wire will appear at the other end of the wire, and that the wire is bi-directional, that is, the wire behaves the same no matter which end is used to transmit the signal (in more complex cases, the signal may be modeled as appearing at the other end of the wire after a time delay). These simple but elegant properties permit straightforward mathematical modeling of communications over wires. These very properties of a wire might be said to be the "missing link" in the design and implementation of software systems.
- object-oriented programming has become widely accepted as a useful procedure to reuse software.
- objects do not communicate by wires, but rather by messages which the objects exchange with one another.
- Each object has a queue from which it retrieves and processes messages.
- the state of an object can be traced by its initial state and by the history of its message queue. Changing the order of arrival of messages obviously affects the state of the object, as well as the system into which the object is embedded.
- changing the order of the arrival of messages from message originators outside the object is not a concern since, at any instant of time, there can only one active object (thread of computation).
- VHDL VHSIC Hardware Description Language
- VHDL is an executable specification language for hardware. It was developed to address the problems of specification, acceptance, testing and reuse in the development, exchange and documentation of digital hardware throughout the life of the system.
- VHDL's model of concurrency is based on physical time, and composition of components is based on the abstraction of wires. The association of interfaces is through equating the end points of ideal wires.
- VHDL is the first concurrent language which has been standardized. The strong emphasis on concurrency and composition gives VHDL the ability to create a uniform description of hardware at multiple levels of abstraction, making VHDL powerful, and of use at all stages of the system life cycle. The following is a brief summary of the benefits of VHDL over other languages. Descriptive Capability
- VHDL can capture the behavior of any digital system at a number of descriptive levels at once. Therefore, it is possible to simulate designs that mix high level behavioral descriptions with low level detailed implementations. Large Scale Design and Reuse
- VHDL is designed to support many different design methodologies. It is appropriate for use in library based tools and equally useful for ASIC based tools. Technology and Process Independent
- VHDL is not based on any information about technology or process assumptions. However, such information can be incorporated in a design using VHDL itself. Design Exchange
- VHDL being a standard can be used to exchange design data among independent organizations developing different parts of the same system. Because VHDL is executable, different groups may test their implementations against simulated high level subsystems provided by others. Public Availability
- VHDL was developed under a government contract and the government has strong interest in maintaining VHDL as a public standard. It is already an IEEE standard 1076, and several organizations including the Department of Defense, IBM, Tl are committed to support it. Government Support The department of defense is currently requiring VHDL descriptions on all contracts that develop ASICs. Since VHDL can be used throughout the life cycle of a digital system, it is likely to become a major component of the procurement process for industry at large. VHDL's ability to describe composition of large systems from component systems based on the hardware model was a key to its realizing the above list of benefits.
- Interface Cycle a process for developing scalable systems based on a model for composition of objects to form larger objects using Interface Cycles.
- Various aspects of the present invention are as follows: 1. A process to compose new Objects from existing Objects, configured with interfaces each comprising an input, output, or both, by the construction and use of Interface Cycles that are canonical abstractions, programs or hardware which interlock protection, distribution and coordination of data and control from multiple Objects, thus allowing the interconnected Objects to form a new Object which may then be used in any stage of the life cycle of the system.
- An Interface Cycle transitions through discrete phases only by agreement of all interfaces connected by the Interface Cycle. Phase transitions and data distribution take place under the control of an Interface Cycle Manager. When all interfaces have released (requested a change of phase of) the Interface Cycle, the Interface Cycle Manager spontaneously transitions the Interface Cycle to the next phase. At this transition point, all data written to the Interface Cycle during the previous phase is made available for reading at the interfaces. All data written to the Interface Cycle is held by the Interface Cycle Manager until the next phase transition, when it is aggregated and distributed in total to the interfaces. Each Object having an interface, may process data concurrently and independently of the others, and may assume consistency of the data read at the Object interface, as long as it has not released the Interface Cycle at its own Object interface.
- An Interface Cycle may be split. That is, a new Interface Cycle may be inserted into an existing one transparent to the Object interfaces of the original Interface Cycle. The new Interface Cycle is inserted immediately after the last Object interface has released the Interface Cycle and its input protection program has executed. Transition to the next phase is deferred until after phase transition of the inserted Interface Cycle.
- each Basic Cycle to include a phase signal which serves to isolate the Object from operations: at the L-type interface during periods of time when the phase of the input is different from the phase of output at that L- type interface; and at the N-type interface during periods of time when the phase of the input is same as the phase of the output at that N-type interface.
- Compose component Objects with Interface Cycles to form larger components and interfaces by listing the component Objects, composite object interfaces, and the connections (Basic Cycles) between the component Object interfaces and the appropriate Interface Cycle Managers.
- Split Interface Cycles at the point in time when the input phase becomes different from output phase at all N-type interfaces of an Interface Cycle Manager .
- Enhance Interface Cycles to define extended cycles by indicating start and end of extended cycles over multiple phase transitions.
- Enhancing Interface Cycles by providing an A-type interface, which, when connected to another A-type interface, negotiates with that A-type interface to assume the characteristics of either an L-type or N-type interface as appropriate while the other A-type interface assumes the characteristics of the opposite type interface. 2.
- a method of programming based on the coordination between Objects through the direct control of interlocked coordination, protection and distribution of data among groups of Objects through uniformly specified interfaces.
- a description associated with each Object there is a program referred to as a description associated with each Object.
- the description has two different forms, a Composite Description for composite Objects (an Object which was composed from component Objects), and an Atomic Description for atomic Objects (an Object which was not composed from component Objects), the composite description comprising a list of input interfaces, a list of output interfaces, a list of component Objects, a list of equivalances of names of component interfaces to names of composite Object interfaces, and a list of connections between component interfaces as discussed above; and the atomic description comprising a list of input interfaces, a list of output interfaces, a list of connections Interface Cycle Managers, and a script of program statements which describes the behavior of the Object in terms of both local variables and the state of its interfaces.
- This script may contain event handlers which are executed whenever a particular port changes phase, or it may poll each interface to check for state changes. It may also send and retrieve data from
- Operational Description Specify atomic descriptions by listing its exposed interface cycles (inputs and outputs), component Objects and connections. Include a script which consists of actions to be performed when any of the interface cycles progress, and actions to be performed when split interface cycles progress. Connect these scripts to form larger scripts by listing exposed interfaces, equivalances, connections and sub-descriptions (component Objects). Use existing descriptions to create new components in a manner analogous to the creation of new data types from existing data types. 3. Specific implementations of this process to interlock protection, distribution and coordination in Interface Cycles.
- Static Interface Cycle wherein all features of the Basic Multi-point Cycle are combined with coordinated notification of exceptions generated by Objects connected to its interfaces, and generalized coordinated notification of protection violations both for input from the interfaces, and output to the interfaces.
- Dynamic Interface Cycle wherein all features of the Static Multi-point Cycle are combined with the ability to dynamically split Interface Cycles transparent to its interfaces. This allows for "hot plug in” of Objects (i.e. the ability to dynamically reconfigure connections between object interfaces, and to replace object descriptions while the system is active).
- a Interface Cycle Controller which, when given a request containing a description of an Object, instantiates all the instances of the component Objects, instantiates all connections between component objects via Interface Cycles, maps interface names according to the Equivalences declared in the Object description, and activates the Object system it has created, after which it returns an acknowledgment to the requester.
- FIGS. 1 and 2 illustrate block descriptions of hardware components
- FIGS. 3 through 7 are used to illustrate some of the interpretation difficulties which arise when composing objects into larger ones
- FIG. 8 illustrates object composition wherein the coordination between components is managed by the interfaces between components rather than managed by the components themselves;
- FIG. 9 illustrates the fundamental communications capability, providing data distribution, but neither coordination nor protection of the data
- FIG. 10 illustrates Basic Directional Transfer, providing data distribution and protection, but no coordination
- FIG. 11 illustrates two objects connected using Basic Directional Transfer
- FIG. 12 illustrates the Basic Cycle Manager, providing data distribution, protection, and coordination
- FIG. 13 illustrates a timing diagram for two objects and a Basic Multi-point Cycle
- FIG. 14 illustrates a timing diagram for an Interface Cycle
- FIG. 15 illustrates a flow diagram for a N interface
- FIG. 16 illustrates a flow diagram for a L interface;-;
- FIG. 17 illustrates an Atomic Interface Description, showing exposed interfaces and an exposed Interface Cycle
- FIG. 18 is a flow diagram for an N interface having input and output protection
- FIG. 19 illustrates a Dynamic Multi-point Cycle Hierarchy and Interface Cycle Controller
- FIG. 20 illustrates a Composite Interface Description, with Atomic Interface Descriptions interconnected by Interfaced Cycles
- FIG. 21 illustrates four Objects and one Static Interface cycle Manager collaborating to perform and print a matrix multiplication example
- FIG. 22 illustrates a composite Object which performs part of the above matrix multiplication
- VHDL uses real-time to describe timing and sequencing among components. For general systems where hardware and software are used, this physical time cannot be used, because there are no real-time guarantees available. Interface Cycles provide for self synchronizing interfaces without reference to real-time. Interface Cycles, at the same time preserve the symmetry and lossless properties of wires on which VHDL is based. In addition, Interface Cycles provides a method to model and implement dynamic hardware and software systems, by finding a way to split cycles dynamically, and thus describe changes in configuration of hardware and software systems. This overcomes the limitation of VHDL to describe dynamically changing wiring patterns while subsystems are active. A basic difference between VHDL and this invention is that Interface Cycles provide a uniform methodology for specifying as well as implementing both hardware and software systems rather than just a language.
- Protection we mean the function of isolating objects from one another such that inadvertent or purposeful corruption of data they are distributing is unlikely. Providing protection internal to the objects is insufficient to achieve this. Objects process data from other Objects and expect certain properties of this input data, in order to function correctly. It is, of course, common today to provide memory protection in modern operating systems, usually supported directly by the hardware. This protection is simple but effective to provide isolation between programs, but does not provide controlled protection. Controlled protection is needed in most systems, because systems cannot be mapped to a memory model which is neatly compartmentalized and static. Most systems need dynamic protection definable in logical terms and specifiable at events that are not directly related to physical hardware level events.
- the distribution of data is the primary method of communication among Objects.
- data that is distributed may represent a request to execute functions, or a request to provide services to other subsystems. Therefore, distribution of data also involves distribution of control.
- improper sequencing of data to and from Objects can easily cause Objects to behave in unpredictable ways.
- an Object when an Object is coordinating with only one other subsystem, it usually knows the others identity and coordinates directly with it, using the knowledge that there is only one other Object involved in the interaction. Even in this simple instance, the sequencing of messages may play a critical role in the interpretation of events. So, if sequencing constraints are violated, then the distribution of data becomes unreliable.
- the function of communication is often understood to mean also coordination. However, even in a two party case, the ability to communicate may not provide the ability to coordinate. If, for example, the communication path is unidirectional, communication does not provide the ability for the two parties to coordinate. Even if there is bi-directional communication, it is necessary to provide coordination to make sense out of what is communicated. This is analogous to the need for synchronization at the lowest hardware level of a directional communications link.
- Coordination is imposing the maintenance of a set of constraints on the joint histories of Objects. While real-time history is not essential for the logic of programs, we must logically specify what the corresponding points in history are, when multiple histories have a common constraint. Such shared histories cannot be externally defined, in the sense that only the programs using the joint history know or care about corresponding points in their respective histories. Therefore, these programs must have full ability to define coordination points.
- multi-point connection linking objects via a two point link is replaced here with a multi-point connection.
- multi-point communication can be achieved by several two party connections, the number of connections grows to be much larger than one in which multiple objects connect via a specific Object.
- the prior art does not provide a canonical abstraction for this Object that is symmetric and lossless like a wire. Interface Cycles does provide the necessary abstraction.
- the basis for the invention is the realization that a process for developing scalable systems based on a model for composition of objects to form larger objects, with the necessary frugality of functions, can have the breadth and power to serve all stages of software development.
- Such methods are common in the hardware development process because of the use of a physical wire to connect components.
- Objects and hardware objects that do not share physical time based clocks do not have the analog of a wire clocked by a real time clock to model connections.
- the Interface Cycle invention provides a method for modeling concurrent software or hardware objects and composing them to form larger objects in such a way that all the stages of system development can be uniformly supported by this composition process.
- the shared history that objects use in the methods described here is the history of uniformly defined interfaces.
- Data structures are described as nested sets.
- An enumerated set is described by the list of its elements, for example: ⁇ a,b,c ⁇ is the set consisting of a, b and c.
- a data structure x represented by x. ⁇ a,b,c ⁇ can have values a, b or c.
- Power sets such as a vector of bits are denoted using ⁇ .
- ⁇ 0,1 ⁇ ⁇ L denotes a vector of L bits.
- [x,y] has two components.
- a nested structure is denoted using the nesting of [] and ⁇ .
- [x. ⁇ a,b,c ⁇ , y. ⁇ d,e ⁇ ] consists of two components x and y where x can take the values a, b or c and y can have values d or e.
- An index used to denote arrays of structures is enclosed in Q; for example: x.[1 ,2,..,N].
- [ ⁇ ] is ⁇ and ⁇ [] ⁇ is same as fj. So, [ ⁇ a, b, c ⁇ ] is the same as ⁇ a,b,c ⁇ .
- ⁇ [a, b, c] ⁇ is the same as [a, b, c].
- a * at a place in a data structure denotes all possible substitutions; for example: x.*.a denotes all elements of the array x that have the value a.
- a % at a place in a data structure indicates that % can be substituted with any one element that can occupy that place.
- So x.%.a indicates any one element of the set x.*.a.
- set x.y.a would be still meaningful because x.y.a fully describes the component that is set.
- nesting is explicitly indicated. For example: begin, end; if then else, endif; etc. When these are placed on a single line by themselves ; may be omitted where unnecessary.
- Standard operator symbols such as arithmetic operators are used without explanation. For example: AND, OR, NOT, + , - , * , /
- Type name : definition of new type in terms of old types example :
- Inputs a. [inl, in2] . ⁇ BOOLEAN ⁇ ;
- Names of Types are either all capitals or start with a capital letter. All other variable instances start with a lower case letter.
- An Object has multiple interfaces and it coordinates the services it provides on these interfaces.
- An interface specifies a set of data structures, services specify what relations are maintained by the Object among the interfaces. The interfaces are assumed local to the object.
- An Object may be restricted from modifying some of the components of its interface. Simple examples of Objects are logic gates, for example, an "and" gate. It has three interfaces: two inputs and one output. The function of the gate does not change the values of the inputs, but uses the values to produce the output. How this gate functions can be described simply as follows:
- Object a.And gate; This notation is analogous to the notation for types we saw earlier for defining instances of types. There can be many instances of objects that are of the same description.
- the description And_gate describes how an "and" gate behaves: the behavior of its inputs and outputs. Usually, as illustrated by And_gate 100 in Figure 1(a), it is interpreted to mean that every time an And gate gets inputs (reference numerals 101 and 102) it produces an output (reference numeral 103) which is the "and” of its inputs. Intrinsic to this interpretation is that there is a cycle in which the inputs are registered and then the outputs are produced. In hardware, we usually ignore a clock (reference numeral 104), because it is always assumed ( Figure 1(b)).
- a very common interface for example, is the function call interface.
- Functions execute a sequence of operations, after the completion of which the names referred to in the argument list may change values, after which the function returns to the same point in the original sequence of operations from where the call to the function was made.
- arguments change, and when they change.
- functions in a way that clarifies these.
- the service offered the computation of And of two inputs.
- This service is obtained by another script that calls the function.
- the line Service describes how such a call is made. No such convention is needed for hardware. Hardware is always specified by the connection between the components.
- the use of functions seems to differ from the way we use gates in hardware. With closer examination, the differences turn out to be less significant. What really happens in a function call is a substitution of the arguments with the specified values at the time of the call.
- Atomic descriptions or sequential programs cannot be interpreted without some guarantees of which variables can be changed and which cannot. This is why the specification of inputs and outputs is important. It is only on local variables that programs can directly operate. When programs are composed together, at least some of these variables have to be connected to others. As long as these connections only connect compatible inputs and outputs, the composed program has some sequential interpretation, as long as the sequencing can be implicitly defined by the connection pattern of inputs and outputs. No input should be "fed" to a component unless the corresponding output to which it was connected is ready. Proper implementation of the object usually creates the illusion that the output one program is the input of the other, even though these two may not have the same value at each instant of real-time.
- Or_gate 110 analogous to And_gate 100, as shown in Figures 1(c) and 1(d). Accordingly, as shown in Figure 1(c), every time Or_gate 110 gets inputs (reference numerals 111 and 112) it produces an output (reference numeral 113) which is the "or" of its inputs.
- Clock 114 shown in Figure 1 (d), is also intrinsic to this interpretation. Thus, the description is:
- Object a.And_gate; b.Or_gate; endObject;
- a new object can be created using the wiring diagram of Figure 3, wherein composite object 300 has been formed by interconnecting objects 200 and 210 of Figure 2 in the manner shown, that is, the inputs 201 and 202 to A block 200 yield an "and" output 203, and the inputs 211 (here same as output 203) and 212 serve as inputs to B block 210 to produce the "or" output 213.
- This same diagram can represent a new object which is described by the connection list:
- Inputs [inl, in2, in3] . BOOLEAN; Outputs : out . BOOLEAN; Components: a.And_gate, b.Or_gate; Equivalences :
- Composit.in2 And_gate. in2;
- Composit.in3 Or_gate.in2;
- Composit.out Or_gate.out; endEquivalences ; Connections :
- And_gate.out Or_gate.ini; endConnections ; endDescription
- Figure 4 explicitly shows And_gate 200 and Or_gate 210 connected in the manner depicted generically by composite object 300 of Figure 3. If the individual descriptions are interpreted based on a clock for each of the descriptions, then we have Figure 5, wherein composite object 300 is shown to have clock 501 serving And_gate 200 and a separate clock 502 serving Or_gate 210. However, if the description is always meant as clocked by a single clock we have Figure 6, wherein composite object 300 is shown as being served by single clock 601. Then again, whether this clock is inside or outside the object (exposed or not) may determine whether components can connect to it if we have a single clock description.
- clock 701 is shown as being inside composite object 300, that is, clock 701 is not exposed to other external objects. It is easy to see that, depending on which scenario we assume, the interpretation of the description is different. In the case of two clocks (Figure 5), for example, the rate at which the And_gate would produces results may be different from the rate at which the Or_gate could produce results. This cannot happen if the two shared a single clock ( Figure 6 or 7). From these examples, it is obvious that the connection list is insufficient to uniquely specify the description of the composite Object.
- the exposed single clock case is what is usually assumed implicitly . In this case, it is easy to see that the composite description is interpreted atomically. Once the number of components becomes large, however, a single clock specifying or implementing the whole system becomes an inadequate model for systems. Different parts of the system must be clocked separately, requiring the description to include information about the sequencing of events in the system. The amount of potential ambiguity which arises and, hence, the complexity of the problem, increases dramatically when the number of objects sharing a connection is more than two (i.e. the connection becomes a multi-cast net instead of point to point). Unfortunately, this is exactly the situation which often arises in large systems because of the need to share data among multiple concurrent processes for reasons of performance and/or reliability.
- Interface cycles on the other hand define clocks on the wires connecting the components rather than on the components themselves.
- clock 801 is inserted in series with output 203 of gate 200 and input 211 of gate 210.
- the connection list does, in fact, specify a unique description. In other words, no additional sequencing information is required in the description to resolve ambiguity.
- the assignment interface can implement an Atomic Transfer.
- Some sample services using this interface are:
- programs may be interrupted. It is possible to interrupt programs at every step, because the interrupt is actually implemented through hardware. Since the method of programming we follow here is event driven, we need such a service similar to interrupt.
- the program atomically branches to a named step in the program that usually corresponds to a handler for the event. This connection between the step and the interrupt is made with install and removed with destall.
- the value of initial and final usually is the status of the event at install and destall time respectively. There is no need to handle the interrupt in a given amount of real-time. Instead, priorities may be enforced. Even without priorities the assumption made is that interrupts will eventually be handled.
- a Basic Directional Transfer is modeled as a wire 901 interconnecting transmitter 1001 and receiver 1002 as shown in Figure 10(a).
- the combination of wire 901 , transmitter 1001 , and receiver 1002 is represented by the Basic Directional Transfer 1010 of Figure 10(b).
- It provides distribution and protection, no coordination. Protection arises from the fact that one end of a BDT may only insert data, while the other may only extract it, thus limiting the capabilities which may be exercised at either end.
- Systems based on prior art use BDTs plus physical time and application specific complex protocols to provide coordination.
- the basic protection provided is through transmitters and receivers that allow information to proceed, in any one cycle, only in direction on the wire at a time.
- we cannot schedule events using a hard real-time clock we need to coordinate by agreement between the Objects themselves. Given two Objects, then this requires at least a full cycle of interaction before an agreement can be reached. This situation gets worse if there are more than two entities coordinating on the same "wire".
- wires have to be replaced by buses to solve the multi-point connection problem. But, unfortunately, buses do not preserve the symmetric, lossless properties of wires which allow us to define precisely how an interconnection of Objects compose to form a new Object.
- Basic Directional Transfer allows the transfer of data from one object to another or transfer of an object from one data to another.
- the end result is the association between an input interface with an output interface without any feed back.
- An example is ordinary but ideal mail: an item can be sent from one location to another and it eventually reaches the addressee in its original form.
- BDT similarly transfers the data most of the time to the addressee. However, we do not insist that the BDT not lose any of the data. Data can be lost. However, there does not exist any data, such that if it is sent via a BDT often enough, it will not be eventually delivered. Thus a BDT can deliver any data correctly if the transfer is tried enough times. However, an item that is lost is assumed to never reappear and be delivered.
- BDT objects consists of two interfaces In and Out. BDT Transfers the value of its In to the value of its Out. So, after every change in the value of In the new value is eventually reflected in Out. However a BDT may do this repeatedly. Every time it samples the value of In it may transfer that value to Out.
- Unreliable packet Transfer is an example. By re-transmitting packets sufficiently many times a packet eventually reaches its destination.
- Most operating systems today have a mechanism to transfer data from one process to another, such as message passing primitives of various flavors. All of them usually include one which is sufficient to implement BDT.
- This call looks like a function call, however, it is usually implemented as a system call needing operating system intervention, and it is not guaranteed that a. in will actually assume the value of b.out at the execution of this statement.
- the ordinary function call provides instantaneous feed back, while BDT does not provide any feedback of its eventual success.
- BDT for our purposes, we implement BDT in a uniform way no matter which underlying resources are used to implement it. This is done by defining an Object called BDT pictorially shown in Figure 10 (a). The object that implements BDT is abstracted and replaced by a line as shown in the Figure 10(b). An object A (200) connected to another object B (210) by BDT 1010 is shown Figure 11.
- BDTM Basic Data Transfer Manager
- NBIN NBOUT
- LBIN LBIN
- LBOUT interfaces for providing its services. These are very simple interfaces which allows copying of some fixed length data from OUT and to IN and IN to OUT respectively.
- ⁇ self> denotes a reference to any specific instance of the interface.
- Type : Data : [ 1 , . . , % ] . ⁇ 0 , 1 ⁇
- NBIN can only be accessed, NBOUT can only be modified.
- the Basic Cycle Manager (BCM) 1200 provides services through another simple cycle interface called NBC, such as NBC 1211 and NBC 1221 of LCM's 1210 and 1220, respectively. Any object having the corresponding LBC interface can connect to get these services from BCM.
- BCM contains another component called Phase which helps keep the integrity of cycles of interaction between the objects that connect to BCM. If the rules of BCM interfaces are followed, the BCM essentially becomes transparent to these objects. The rules after initialization are simple.
- BC [phase. ⁇ 0, 1 ⁇ , data. [1, .. , L] . ⁇ 0, 1 ⁇ ] ;
- Access only NBC. in and modify only NBC. out For initiating a new cycle, change NBC. out. phase to be the same as NBC. in. phase. Except for the first cycle, access NBC.in and modify NBC. out only when NBC. in. phase is not equal to NBC. out .phase. In the first cycle initialize NBC. out.phase; endPDC; endlnterface
- the interfaces NBC and LBC are exactly the same once initialized.
- the LBC yields the phase to the NBC when connected. This is the only difference.
- Interlocked Protection, Distribution and Coordination are provided by read and write functions at the two ends that only operate on certain parts of the data structures and only at certain times of the cycle. Obviously, read above, while write makes available at the NBC interface the results of the set LBC out . data or try LBC . out . data services.
- BMC connections are as : a . l .
- NBMC x .
- NBMC y .
- NBMC z . LBMC
- Each object can assume x .
- LBMC y .
- LBMC z .
- LBMC at the beginning of each cycle at its LBMC.
- the Basic Cycle is a symmetric cycle of merging all the data contributions of all the objects into one Bag and distributing them when all have collaboratively decided to do so in a symmetric way. Bags are like sets except that they allow for multiple copies of the same element. Two Bags are the same, therefore, if every element in one occurs the same number of times in the other and vice versa.
- the interfaces for the BMC is very much like the BC except for the differing sizes of the Data component to accommodate Bags.
- NBMC are LBMC are described below:
- Type: BMC: [phase. ⁇ 0, 1 ⁇ , data. [1, .. , L*N] . ⁇ 0, 1 ⁇ ] ;
- Access only NBC. in and modify only NBC. out For initiating a new cycle, change NBC. ou .phase to be the same as NBC. in. phase . Except for the first cycle, access NBC. in and modify NBC. out only when NB. in. phase is not equal to NBC. out .phase. In the first cycle initialize NBC. out .phase; endPDC; endlnterface
- FIG. 13 there is shown a timing diagram for two objects (denoted Object 1 and Object 2) and a Basic Multi-point Cycle (BMC), as based on the pseudo-code set forth above for the BMC.
- the discussion of FIG. 13 uses time point 1301 as the reference point (this time point may be equivalent to, for example, the starting point for the series of basic multi-point cycles after initialization).
- Objects 1 and 2 access their respective interfaces (based on the pseudo-code above for an object interface, i.e., the LBMC interface, wherein between the PDC and endPDC delimiters it is stated: " Access only LBC. in and modify only LBC. out ... only when LBC. in. phase is equal to LBC. out. phase", so at time point 1301 it is postulated that the in. phase and out.phase of each object are equal).
- the period of access to its interface occurs over the time interval 1310 (see line (i) of FIG. 13).
- the period of access occurs over the time interval 1320 (see line (ii) of FIG. 13).
- time interval 1330 (see line (iii) of FIG. 13) following starting time 1301 is a period of no-access, awaiting notification of changed phases in Objects 1 and 2 (based on the pseudo-code above for a basic multi-point cycle interface, i.e., the NBMC interface, wherein between the PDC and endPDC delimiters it is stated: " Access only NBC. in and modify only NBC. out ... only when NBC. in. phase is not equal to NBC. out.phase", so at time point 1301 it is postulated that the in. phase and out.phase of this interface are not equal).
- Time interval 1310 ends at time point 1311 , when Object 1 changes out.phase to be different from its in. phase; Object 1 then enters a no-access period, designated by time period 1312, during which access to LBC. in and modification of LBC. out are invalid.
- Time point 1311 is shown by an up-arrow which has the symbolic meaning that a phase change has been posted by Object 1 to its interface.
- the BMC detects the phase change in Object 1.
- the down-arrow has the meaning that a change-of-phase has been detected by the BMC.
- Object 2 has not yet signified a change in the phase flag in its interface, accessing Object 2's data is not yet a valid operation.
- Object 2 has posted a change in phase (up-arrow) to its interface, and Object 2 now enters a no-access state of duration 1322, during which period access to its LBC. in and modification to its LBC. out are invalid.
- the BMC detects the phase change in Object 2.
- the BMC may now access its NBC. in and modify its NBC. out interface so as to carry out the process of accumulating data from the interfaces of Objects 1 and 2 to form the complete bag - this period of activity is denoted by time period 1334 on line (iii).
- time period 1334 is also used to distribute the bag to the interface of each object (as shown in the pseudo-code for the BMC that follows: "distribute").
- the BMC posts a change of phase at time point 1333, i.e., NBC. in. phase and NBC. out.phase are made equal, thereby signaling that Objects 1 and 2 may spontaneously advance to the next cycle of processing.
- the change of phase in the BMC is actually detected by Object 1.
- Access to LBC. in and modification of LBC. out of Object 1's interface are now valid.
- a basic cycle 1315 for Object 1 has now been completed; the cycle in this case is measured by the time interval between time points 1313 and 1301.
- An Interface Cycle may be described as a subset of the BMC in that only one object interacts with the Interface Cycle Manager (ICM) - which is commensurate with the BMC in this special case.
- ICM Interface Cycle Manager
- FIG 14 there is shown a timing diagram for the Object and the ICM, as based on the pseudo-code set forth above for the ICM.
- the discussion of Figure 14 uses time point 1401 (see line (i) of Figure 14) as the reference point (this time point may be equivalent to, for example, the starting point for the series of basic cycles after initialization).
- time point 1401 the Object accesses its interface.
- time interval 1430 (see line (ii) of Figure 14) following starting time 1401 is a period of no-access, awaiting notification of a changed phase in the Object.
- Time interval 1410 ends at time point 1411 , when the Object changes its out.phase to be different from its in. phase; the Object then enters a no-access period, designated by time period 1412, during which access to LBC. in and modification of LBC. out are invalid.
- Time point 1411 is shown by an up-arrow which has the symbolic meaning that a phase change has been posted by the Object to its interface.
- the IMC detects the phase change in the Object.
- the down-arrow has the meaning that a change-of-phase has been detected by the ICM.
- the ICM is activated and may obtain data from the interface of the Object to begin formation of the bag of data.
- access time period 1434 is also used to distribute the bag to the interface of the Object.
- the ICM posts a change of phase at time point 1433, i.e., NBC. in. phase and NBC. out. phase are made equal, thereby signaling that the Object may spontaneously advance to the next cycle of processing.
- the change of phase in the ICM is actually detected by the Object. Access to LBC. in and modification of LBC. out of the Object's interface are now valid.
- a basic cycle 1415 for the Object has now been completed; the cycle in this case is measured by the time interval between time points 1413 and 1401.
- the Object now enters the access period 1414 of the next basic cycle.
- the ICM has also completed a basic cycle, denoted by the time interval between time points 1433 and 1401 , and the ICM enters a non-access period 1436 to again await change of a phase indication by both the Object.
- BMC's operation is very simple. When all of its NBMC interfaces have changed phases, all objects connected to them have completed a new set of modifications to their own LBMC interfaces. They are all then waiting to detect a phase change. BMC gathers all of the new bags from the objects and makes a single new bag. It then delivers them to each one of its own NBMC interfaces. This makes the basic unit of data distributed to be lossless and the distribution itself to be symmetric in the sense all the data is available to all of the parties each of the cycles. By not restraining the cycle externally and preserving the contributions of each without necessarily identifying object names BMC abstracts the interfaces to a common coordinated interface.
- BMC Basic_Multipoint_Cycle
- Interface interface. [1, .. ,N] . (NBMC) ;
- processing block 1510 is first invoked to initialize the BMCs N interface.
- processing block 1520 is invoked to determine if the N interface has received phase change indications from the objects associated with the N interface - block 1520 is shown as being the starting point in the cycle ("Start Cycle").
- Start Cycle There are at least two options to consider with respect to detecting the phase indications.
- One option, depicted in Figure 15, is to wait until all objects associated with a given N interface have provided phase change indications. Then the N interface is proceeds to processing block 1530 wherein the L interfaces are scanned for input.
- An alternative arrangement depicted by the timing diagram of Figure 13, is to process each object as it signals the N interface that the object's interface can be accessed.
- the latter case is more efficient in that the formation of the bag may be ongoing as each object allows access to its interface.
- the next processing stage is entered via block 1540 which denotes formation of the bag from the data obtained from the L interfaces.
- processing block 1550 is entered to distribute the bag to the L interfaces.
- Block 1560 denotes that at the end distribution of the bag, the phase of the N interface is toggled so as to alert all L interfaces associated with the BMC that their period of no-access is completed — processing block 1560 is the end of the BMC cycle ("End Cycle"), and the "Start Cycle” block 1520 is re-invoked at this point in the processing.
- flow 1600 is the processing representative of each L interface associated with a given BMCs N interface.
- Processing block 1610 again signifies an initialization stage, followed by the processing of block 1620 - the "Start Cycle" for the L interface.
- the L interface awaits a change of phase indication as delivered by the N interface.
- processing block 1630 is invoked wherein the L interface uses its local services.
- processing block 1640 is entered to toggle the phase of the L interface so as to inform the associated N interface that the L interface has entered the period of no-access between its local services and the L interface.
- the "Start Cycle" block 1620 is re-invoked.
- the Dynamic Multi-point Cycle allows dynamic changes in the system configuration. These changes can be made while the system is active, providing capabilities analogous to "hot plug in” hardware.
- the Dynamic Multi-point Cycle Manager (DMCM) 1710 is situated as shown in Figure 17, managing a set of L-type interfaces for client objects (labeled OBJ) 1701 and 1702, and connected to zero, one, or two other DMCMs via set of Basic Cycles, allowing the DMCMs to communicate with one another in cycles. For instance, in Figure 17, DMCM 1730 connects to DMCM 1710 via Basic Cycle 1721 , whereas DMCM's 1710 and 1720 are coupled by Basic Cycle 1711.
- DMCMs interconnected by BCs, are not peers. One of them always has higher priority than the other. Specifically, with respect to the BCs between them, the DMCM with the L-type interfaces is of lower priority than the DMCM with the N-type interfaces. Thus DMCM 1730 is of a lower priority compared to DMCM 1720. In addition, DMCM's 1710, 1720, and 1730 are coupled to Interface Cycle Controller 1740, whose function will be described below.
- Each set of objects connected to a DMCM and labeled OBJ in Figure 17 share a Multi-point Cycle. However, they do not share this cycle directly with each other as they would if they were participating in a Basic Multi-point Cycle. Instead, cycles are always mediated by the DMCM. There are several directions (routes) in which cycles may proceed. At each level (priority), an object can request, through its cycle with the DMCM it is connected to, a direction in which the cycle should proceed. This request also allows it specify which possible directions it is agreeable with, since all objects may not always agree on a common direction, and latitude may allow a consensus direction. The DMCM routes Cycle based on inputs from these Objects and a set of rules.
- the priority of the levels relative to each other guarantees certain invariant properties in the direction which is selected by the DMCM. Whenever the OBJ interfaces at the next higher level collectively want to intercept the cycle of the lower level they can do so. This is because in every cycle, after a phase change has occurred on the IN side of the BC to each OBJ, a level waits for permission from the higher level to proceed to the second part of the cycle. If permission is granted for a particular set of directions it selects a valid direction and completes its distribution functions. If the only permitted direction is to the higher level it hands over the bag to the higher level to distribute to the OBJ interfaces at the higher level.
- the level wants attention from the one above to get the current cycle intercepted, it waits for the upper level to give attention. Once a level is in the waiting mode for the higher level, it does not proceed to the second half of the cycle in progress, until the higher level has authorized it, at which time it distributes the inputs from the higher level to the outputs of the lower level.
- This control of routing of inputs to outputs is coordinated with components of the N- type and L-type interfaces that, at each level attempt to set the routing pattern at their own level and at the next lower level.
- the pattern set for the lower level can be changed in every cycle. However, if the level itself is currently routed to the higher level, the route setting for the lower level is unaltered in the period while the cycle with higher level is in progress.
- the request set on the interfaces is fused to into a single request that is then resolved with the requirements of the higher level.
- the method involves a rule that can be implemented on two requests at a time, where the requests can be non-deterministic (the requester can allow the DMCM to choose from one of a set of allowable choices). Within these constraints, actual policies are implemented via an installable function into the DMCM.
- d_global is the distribution direction of the current cycle.
- d_level is the ditribution direction wanted as a group by the level.
- d_lower is the new ditribution direction set by group for the lower level.
- d_lower_req is the requested distribution direction by the group at lower level.
- NDMC [phase . ⁇ 0, 1 ⁇ , data. [1, .. , L*N] , [d_global, d_level, d_lower, d_lower_req] . (D_Event) ] ;
- d_level is the distribution direction wanted by the interface.
- d_lower is the distribtuion direction of the lower level wanted by the interface endRemark;
- LDMC [phase. ⁇ 0, 1 ⁇ , data. [ 1, .. , L] . ⁇ 0, 1 ⁇ , [d_level, d_lower] . (D_Event) ] ;
- the LBC and NBC interfaces are for the level to communicate with the higher and lower levels or Interface Cycle Controllers. endRemark;
- DMCI level. [1, ..,N] .
- control, h_d_event, h_global : ⁇ NBC) ; control .data. [have_up, have_down, active . [1, .. ,N] ].
- Locals have_up. ⁇ yes, no); have_down . ⁇ yes , no); active. [1, .. ,N] . (yes, no); c_acive. [1, ..N] ; ready. [1, .. ,N] . (yes, no) ; local. [1, ..,N] . ⁇ LDMCI ⁇ ; global. (NDMCI) ; total. (INTEGER); endLocals ;
- Remark Start polling each interface for new cycle and associated input.
- the program IP copies the input from the interface to the correct positions of the global data structure and also sets d_Events . Since some of these are only formed by consensus, the variable first_time allows sequencing consensus forming one at a time.
- IP global. (NDMCI) ; level . i . ⁇ LDMCI ⁇ ;
- the Static Interface Cycle is a Basic Multi-point cycle which is enhanced with critical functions for protection and exception handling.
- Static Interface Cycle Managers indicate the various exceptions that could occur in a realistic environment. SICMs distinguish between the exceptions explicitly created by the objects or exceptions arising from violation of a protection policy.
- Every phase change at the LSIC interface is accompanied by a coordination event. These are used to signal exceptions explicitly generated by the Objects and delivered via the object interface.
- Coordination events include: off (no exception condition), abort, retract, and repeat. Abort takes precedence over retract and repeat, and retract takes precedence over repeat. Abort represents the most serious condition, and should not be signaled by an object unless it deems it necessary to reinitialize the interface. Retract is a less serious event and, in general, should be used to signal all interfaces to begin processing as they had just entered the previous phase of the SIC (two phase transitions prior to the most recent one).
- a repeat event signals objects to restart processing at the current phase (one phase transition prior to the most recent one).
- the off event accompanies any phase transition in which there is no abort, retract, or repeat. Unless the prior coordination event was off, the data component of LSIC interface is unreliable (i.e. attempting try on the data will not succeed).
- the SICM is configured with special programs that protect the interfaces connected to it. These programs, called Input Protection Programs (IP) and Output Protection Programs (OP), are loaded into the SICM using a protection scheme that allows only authorized agents to load them when an SICM is initially configured.
- IP Input Protection Programs
- OP Output Protection Programs
- IP Input Protection Programs
- OP Output Protection Programs
- the scheme might depend on application requirements and does not have to be uniform.
- the point at which the IP and OP are executed namely the point where all the interfaces connected to an SICM have changed phase, but the SICM itself has not changed the phases of its NSIC interfaces, is important.
- C_Event : ⁇ Repeat, Retract, Abort, OFF
- P_Event : [in, out]. (ON, OFF);
- NSIC [phase . ⁇ 0, 1 ⁇ , data . [ 1, .. , L*N] . ⁇ 0, 1 ⁇ , c_global . ⁇ C_Event ⁇ , p_local . ⁇ P_Event ⁇ , p_global . ⁇ P_Event ⁇ ] ;
- LSIC [phase. ( 0, 1 ⁇ , data . [1, .. , L] . ⁇ 0, 1 ⁇ , c_local . (C_Event) ]
- LSIC_normal [phase.0, data. [1, .. L] .0, c_local . OFF] ;
- Output out. ⁇ NSIC
- endlnterface Interface LSICI
- Input in . ⁇ NSIC ⁇ ;
- Output out. ⁇ LSIC ⁇ ; endlnterface; Description: Static_Interface_Cycle (SIC) ;
- the Dynamic Interface Cycle provides the union of the capabilities of the Dynamic Multi-point Cycle (DMC) and the Static Interface Cycle (SIC) discussed previously.
- the IP and OP installable functions implement both protection and routing policies; and initiate coordination, protection and routing events.
- An Extended Interface Cycle is an enhancement to all Multi-point Interface Cycles wherein each interface maintains additional information on the start and end of the extended Cycle. This allows multiple atomic interactions over each interface (Basic Cycle) to take place for each phase transition of the Multi-point Cycle.
- BC.micro phase a new item called micro_phase.
- BC.micro phase would then be used in place of BC. phase in all behaviors of both sides of the BC interface.
- change_phase would be made available at the interface, which would be used to explicitly change the phase of the interface as far as the Multi-point Cycle is concerned.
- the individual interfaces would function based on BC.micro phase, while the Multi-point Cycle would continue to function on BC phase .
- Atomic Descriptions are like event driven programs. They continue to sequence through operations and branch to specific sequences determined by the event detected by the program. To describe these operations, a minimal notation is needed because of the variety of names and operations that are necessary. Therefore, we start by explaining the notation used in this application.
- An Atomic Interface Description for object 1900 in Figure 19 is a list of Exposed Interface Cycles (such as cycle 1910), a listing of Exposed Interfaces (such as 1901-1904), a list of connections between component objects, an Atomic Cycle, a Domain of Local Names, and a flow chart (or script) which is interpreted relative to the Atomic Cycle and the Domain of Local Names.
- the flow chart may be replaced by any method to describe a sequence of operational steps relative to the Atomic Cycle.
- Such operations include operations on Interfaces.
- a sequential program is one with a specified Atomic Cycle specifying the atomic steps, namely steps during the execution of which, none of the local names can change.
- Another example is the description as a finite state machine.
- the Composite Interface Description also includes a list of Exposed Interface Cycles (such as cycle 2010) and a list of Exposed Interfaces (such as 2001-2003).
- Interface cycles 2030 and 2031 are internal and are not part of the list of Exposed Interface Cycles.
- interfaces such as interfaces 2035 and 2036 are internal and are not listed on the Exposed Interface list.
- Interface Cycle Objects have uniform interfaces. They are paired N-types and L- types. N-type interfaces are prefixed by N while L-type interfaces are prefixed by L. An N- type interface can only be connected to an L-type interface. Each interface is divided into two main components called In and Out. The In component cannot be locally modified. The Out component can be locally modified. The basic components of In and Out themselves are Phase and Data. The Data portion has some constraint on length and can be used to represent any data structure that fits into it. The Phase component has a value of the phase itself which can either be 0 or 1 , and an Event component which is used to monitor exceptions. These interfaces are treated as local variables of the object.
- N side and L side The main difference between the N side and L side is that when an L side is first connected to an N side, it yields the starting phase to N. Once the connection is initialized, a pair of Atomic Attempt Cycle services can maintain it. These functions use their own variables to store the state of the interface and control access to it by programs within the object.
- the Dynamic Interface Cycle Manager performs the functions of initializing each of the managers and objects, further it coordinates the activation or powering up of the objects. Objects which are just specifications become active and start responding to cycles. This is very analogous to hardware, where the definition of a system in terms of the interconnection of components is powered up by supplying each component with electrical power.
- Interface Cycle Controller is a facility for 1) the dynamic creation (instantiation and activation) of Objects from their Descriptions, and 2) for dynamic connection and disconnection of Object interfaces to other Object interfaces via Interface Cycles.
- Interface cycle controller When Interface cycle controller is passed a request to instantiate an object, it is given 1) an Object description, and 2) some location identifier which indicates the neighborhood (typically processor) where the new object should be instantiated.
- Interface Cycle Controller Upon successful instantiation of the new Object, Interface Cycle Controller returns a unique Object identifier to the requester. If Interface cycle controller is unable to successfully instantiate the new Object, it notifies the requester of this condition.
- Interface cycle controller When Interface cycle controller is passed a request to set up a connection, it is passed 1) an Object identifier, 2) an interface name, and 3) an Interface Cycle identifier. If the Interface Cycle identifier is NULL, or if the Interface Cycle named by the Interface Cycle identifier does not already exist, Interface cycle controller creates a new Interface Cycle Manager either with the supplied Interface Cycle Identifier, or with a new Interface Cycle Identifier (if the request contained a NULL Interface Cycle Identifier), and returns the Interface Cycle Identifier if successful, or FAIL if the request could not be satisfied.
- Interface cycle controller In order to instantiate a new Object, Interface cycle controller must recursively instantiate any component Objects of a composite Object, and interconnect their interfaces using Interface Cycles. To do this, Interface cycle controller first creates an Interface Cycle Manager, and then uses information from the Object Description to connect the interfaces of the component Objects to the interfaces of the Interface Cycle Manager. Configure Interconnection of Objects Using ICM's
- SICMs Composite objects are built by interconnecting existing objects through SICMs. These interconnections specify the individual components, SICMs and their connections. DIM first scans the connection list and initializes SICMs with IPF, OPF programs. Each instance of an SICM is owned by a Protection Domain which is a set of specific policies implemented in IPF and OPF. Unless authorized by the owner, the initialization fails. This causes all the NSIC interfaces to be initialized determining the starting phase and the set of programs that interlock protection with distribution and synchronization. It then uses its own BCs or BMC to realize the prescribed connectivity. Configure ICMs with Input and Output Protection Programs
- ICC When an Interface Cycle is created, ICC loads them with default Input and Output protection programs. However the creator of the object another object or a person can authorize the loading of special protection programs. This is possible, because the ICC checks the validity of the request using a form of digital signature verification. These programs can specific to cycles and can be installed in such a way that the privileges an object has may get altered after the lapse of a fixed number of cycles. In a dynamic system, when the Cycle Manager has a protection port, much like the control port of the Dynamic Multipoint Cycle, these protection programs may be altered without destroying the Cycle.
- Each Interface Cycle could itself be created by specific programs that are the implementers of unique policies. These, called Protectors here, determines an algorithm that checks the validity of data that is distributed through the Interface Cycle. The data is validated by algorithmically determining whether the data in fact satisfies the requirements of the Protector. These may depend on the cycle itself. Data that may satisfy the protection requirement in a certain cycle may not satisfy the requirement in another. Therefore, a duplicate of a data item sent by a valid Interface Object cannot be used by another in a way to corrupt the data of another.
- the algorithm for checks need not be installed by the protector, it can be a fixed algorithm like those used in public key signature systems.
- an Interface Cycle may have an algorithm to check type compatibility and check for the operations requested through from objects can be verified before adding to the Bag of data associated with the cycle. Some of the Objects can be blocked from adding to the bag when they should not by making this check a function of the count of the cycle. Therefore, the applicability of the function is checked at run-time namely when the object has already been activated.
- the Interface Cycle Controller can also activate and deactivate objects.
- the activation of an object is done by acquiring system resources it needs such as CPU and memory and then loading and executing the code corresponding to composite objects after all the required Interface Cycle Managers needed for connecting them are themselves activated.
- the Dynamic versions of Cycle Managers provide for splitting cycles in a controllable way so that activation of objects can be sequenced and synchronized.
- the same facility is used for deactivation of composite objects. For this, the IC's first activate connections by activating cycles at various levels of Dynamic Interface Cycles, then through these connections deactivate other connections at lower levels and then deactivate the objects themselves.
- the Interface Cycle Process may be used in any stage of the system development process to model systems of objects or to implement them. We describe here the key steps involved. These are the creation and maintenance of a library of components much like libraries of hardware components that can be reused by interconnecting them with Interface Cycles that suit the application. Create Library of Components of ICO s and ICMs
- Objects specified using one of the many Interface Cycle interfaces are represented by their executable codes, in a data base.
- This data base has the representation of the components in terms of the exposed interfaces, Interface Cycle Managers and Connections.
- the library also contains information about the IP and OP programs that handle those interfaces. These programs provide such functions as checking whether the type of data structures that are expected at the ports are in fact the ones presented by the Interface Cycle Managers. Because the library is based on the notion of composition using Interface Cycles, it is possible to derive a unique description of a composite object from the descriptions of the component objects. Were it not the case, reuse of the library would need extraneous information to disambiguate a composite description.
- the manger's main functions are to provide convenient access to the library of existing components and those that are in process of development so that they can be safely connected for test or development purposes.
- a key to this is the implementation of a protection policy across the interfaces of objects.
- These policies are programs as described above which are changeable by the library manager depending on the reliability of the code being developed. As an object becomes more and more reliable, it can be restricted less and less and the neighboring objects in connections can be allowed to use more of its functions.
- the manager of the library implements such policies. Create and Maintain the Environment Using ICC's
- the environment for using the library for simulation or implementation requires the activation and deactivation of composite objects in a controlled way.
- the Interface Cycle Controllers synchronize the activation of different components so that a composite is activated in an orderly fashion. Because of the fact that all inter object connections are standardized through the Interface Cycles, the environment can be created without understanding the use of components. It is necessary to know which of the required connections have to be activated together and which have to be sequenced. This installer itself can be made into an Interface Cycle Object which by controlling the Dynamic Interface Cycles explained above gets a higher level of control of the connections than the composite object itself. It can use this control to sequence in safe way the connections. Such sequencing together with resources to execute the script of objects provides sufficient functions to compose objects and then "hot plug" them into an existing interconnection of objects. Once again because of the canonical model for composing based on Intercycle Managers.
- the system consists of four Objects shown in Figure 21 , each with one interface coupled to SICM 2150.
- HO, (2110),HO 2 (2120), andHO 3 (2130) are used to calculate x, ,x 2 , and x 3 ⁇ respectivley
- HO 4 (2140) is used to print the results via printer 2160.
- the Protector could load the cycle with a Input Protection Program that checks that the input conforms to the correct format for numeric data.
- the Output Protection Program could check the number of elements in the bag and the properties of the whole bag before distributing them to the Ports.
- the input protection program could insert codes into the element of the bag it contributes which allows the output protection program to selectively transform the formats.
- the composite Object consists of three multiplier Objects 2220, 2221 , and 2222 and one adder Object 2230, and two exposed Interface Cycles, interconnected as shown in Figure 22.
- SICM 2250 is used for distribution of data among the objects as in the previous example. Atomic Interface descriptions for the adder and multiplier Objects are provided below.
- the entire matrix multiplication system consists of three of these composite objects, one printer object as in the previous example, and one configuration object with 12 ports which initializes each adder and multiplier object.
- SICM 2250 is shared by all three composite Objects and the printer object.
- Script begin start : if read (CONFIGURE not INVALID) then parse (read (CONFIGURE) into index and mult; else go to start end if loop: if read (IN not INVALID) then parse read (IN) into X[]; write (mult * x[index]) to OUT; end if go to loop; end
- Interface object Adder: Exposed Interface Cycles: none Exposed ports: IN, OUT, CONFIGURE; Script: begin start : if read (CONFIGURE not INVALID) then read (CONFIGURE) into index; else go to start end if loop: if read (IN not INVALID) then parse read (IN) into X[]; write (index,x[l]+x[2]+x[3] ) to OUT; end if go to loop; end
- Use Interface Cycles to implement distributed data bases without centralized locking protocols.
- Use mediation programs which split the database update cycle using DICs, to detect and resolve collisions immediately after they occur, but before they reach the database. Protocol synthesis
- a graphical tool possibly an existing Computer Aided Design (CAD) schematic capture system modified to recognize Interface Cycles instead of real-time, to specify and simulate systems. Users can select components from a library, modify and interconnect them using a graphical interface, and then directly execute the graphical specification.
- CAD Computer Aided Design
Abstract
Description
Claims
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
PCT/US1997/010465 WO1998058312A1 (en) | 1997-06-16 | 1997-06-16 | Composition of systems of objects by interlocking coordination, protection, and distribution |
AU34903/97A AU3490397A (en) | 1997-06-16 | 1997-06-16 | Composition of systems of objects by interlocking coordination, protection, and distribution |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
PCT/US1997/010465 WO1998058312A1 (en) | 1997-06-16 | 1997-06-16 | Composition of systems of objects by interlocking coordination, protection, and distribution |
Publications (1)
Publication Number | Publication Date |
---|---|
WO1998058312A1 true WO1998058312A1 (en) | 1998-12-23 |
Family
ID=22261096
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US1997/010465 WO1998058312A1 (en) | 1997-06-16 | 1997-06-16 | Composition of systems of objects by interlocking coordination, protection, and distribution |
Country Status (2)
Country | Link |
---|---|
AU (1) | AU3490397A (en) |
WO (1) | WO1998058312A1 (en) |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0631232A2 (en) * | 1993-06-25 | 1994-12-28 | Microsoft Corporation | Integration of systems management services with an underlying system object model |
US5519875A (en) * | 1991-08-08 | 1996-05-21 | Hitachi, Ltd. | Distributed processing system for modules, each having modularized objects |
US5572733A (en) * | 1993-05-25 | 1996-11-05 | Fujitsu Limited | Data processing system which executes composite objects by combining existing objects |
-
1997
- 1997-06-16 WO PCT/US1997/010465 patent/WO1998058312A1/en active Application Filing
- 1997-06-16 AU AU34903/97A patent/AU3490397A/en not_active Abandoned
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5519875A (en) * | 1991-08-08 | 1996-05-21 | Hitachi, Ltd. | Distributed processing system for modules, each having modularized objects |
US5572733A (en) * | 1993-05-25 | 1996-11-05 | Fujitsu Limited | Data processing system which executes composite objects by combining existing objects |
EP0631232A2 (en) * | 1993-06-25 | 1994-12-28 | Microsoft Corporation | Integration of systems management services with an underlying system object model |
Also Published As
Publication number | Publication date |
---|---|
AU3490397A (en) | 1999-01-04 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US5640546A (en) | Composition of systems of objects by interlocking coordination, projection, and distribution | |
Reed et al. | Synchronization with eventcounts and sequencers | |
Diaz | Modeling and analysis of communication and cooperation protocols using Petri net based models | |
US20090006810A1 (en) | Mechanism to support generic collective communication across a variety of programming models | |
Agha et al. | A linguistic framework for dynamic composition of dependability protocols | |
Gien | Micro-kernel architecture key to modern operating systems design | |
JP2005504455A (en) | Adaptive multi-protocol communication system | |
WO1995002219A1 (en) | System and method for distributed computation based upon movement, execution and interaction of processes in a network | |
Kramer | Distributed software engineering | |
Von Bochmann | Concepts for distributed systems design | |
Kraemer et al. | Aligning UML 2.0 state machines and temporal logic for the efficient execution of services | |
Kato et al. | SDE: Incremental specification and development of communications software | |
WO1998058312A1 (en) | Composition of systems of objects by interlocking coordination, protection, and distribution | |
Fleischmann et al. | Specification and implementation of an ISO session layer | |
Williamson et al. | Concurrent communication and synchronization mechanisms | |
Dulay et al. | Distributed system construction: Experience with the conic toolkit | |
Gien | Next generation operating systems architecture | |
JPH1091448A (en) | Object directional computing system | |
East | The Honeysuckle programming language: an overview | |
Sager et al. | System 75: The Oryx/Pecos Operating System | |
JP4668367B2 (en) | Computer, parallel distributed system, and function call method | |
Kermarrec et al. | Ada communication components for distributed and real time applications | |
Choy et al. | Efficient implementation of synchronous communication over asynchronous networks | |
Urueña et al. | Building high-integrity distributed systems with Ravenscar restrictions | |
Tsukamoto | Structuring distributed programs with control fault detection |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A1 Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GE GH HU IL IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK TJ TM TR TT UA UG UZ VN YU ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A1 Designated state(s): GH KE LS MW SD SZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
NENP | Non-entry into the national phase |
Ref country code: CA |
|
NENP | Non-entry into the national phase |
Ref country code: JP Ref document number: 1999504339 Format of ref document f/p: F |
|
122 | Ep: pct application non-entry in european phase |