Classifications

• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F9/00—Arrangements for program control, e.g. control units
  • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
  • G06F9/46—Multiprogramming arrangements
  • G06F9/54—Interprogram communication
  • G06F9/542—Event management; Broadcasting; Multicasting; Notifications

Definitions

• Application programs used within computerized systems typically include a number of different components or modules that depend on each other for various different reasons.
• a simple calculator application program might include an output display component, which immediately refreshes (i.e., displays new output) any time it identifies one or more values output from a calculation module.
• the calculation module in turn, might be configure to execute a calculation any time it receives one or more number and function inputs from one or more input components.
• the display component would be dependent not only on the calculation module, but also ultimately on each of the various input components in the calculator application.
• these dependencies can be configured on a software level.
• the above-described calculator module might "publish” its calculated values so that any other display component that is “listening” for the value will identify and execute some action on the value when published.
• the display component might, in turn, establish a listener (e.g., establish an "event"), which ultimately identifies and/or receives the published value.
• the calculator module might itself be configured to pass (e.g., "signaling") any newly calculated value to a particular other component that is registered with the calculator module.
• any time a programmer wants to create a dependency between modules or components the programmer will typically need to write a dependency in the code, and sometimes even create a listener for the relationship.
• the programmer might write a listener that not only retrieves a value when it is published by one component, but also sends the value on to another component in a dependency chain.
• the programmer might also or alternatively write in other logic whereby the component only sends the value onward when some particular condition is satisfied (e.g., the value is of a particular size).
• some particular condition e.g., the value is of a particular size
• one dependency chain might involve a dependency from source node A, to intermediate node C, and then to end-node D.
• node A may only need a value from end-node D.
• end-node D may only need to know that source node A has changed, without necessarily needing the value of source node A right away.
• the second execution context would still involve relay of the actual value of the change from A to C to D, even though D only needs to know that A changed.
• Implementations of the present invention provide systems, methods, and computer program products that ensure a synchronized approach to delivering, reporting, and/or otherwise processing status/value changes in complex software dependency chains.
• implementations of the present invention include a two-phase approach in which the system establishes a node graph corresponding to dependency chain of software components, and only calls all listeners in the node graph after all nodes have been signaled.
• implementations of the present invention can ensure that all listeners receive values based on effectively the same state for the relevant source components, and in appropriate order, thus ensuring consistency.
• a method in accordance with an implementation of the present invention for processing a consistent set of one or more values in dependency chain can involve creating a plurality of nodes corresponding to a plurality of components that include one or more source components and one or more dependent components that are ordered in a dependency chain.
• the method can also involve, for each node, setting a binary indicator to a first setting that indicates that one or more source components comprise an initial status.
• the method can involve, upon identifying a change to a subsequent status in the one or more source components, setting each binary indicator for each node to a second setting.
• the method can involve calling one or more listeners that have been registered with the created plurality of nodes.
• another method in accordance with an implementation of the present invention for creating and updating in-memory data structures based only on a set of guaranteed values can involve creating an initial node graph.
• the initial node graph corresponds to a plurality of components that include one or more dependent component that depend from one or more source components.
• each node of the initial node graph is set to a first setting.
• the method can also involve, upon identifying that the one or more source components have changed to an updated value, caching the updated value, and initiating all listeners registered for the initial node graph to perform processing based on the updated value.
• the method can involve discarding the initial node graph after all initiated listeners have finished processing based on the updated value. Furthermore, the method can involve creating a subsequent node graph based on one or more subsequent changes to the one or more source components.
• Figure IA illustrates an overview schematic diagram in which a signaling system identifies nodes of a dependency chain in accordance with an implementation of the present invention
• Figure IB illustrates an overview schematic diagram in which the signaling system signals each node in a dependency chain in accordance with an implementation of the present invention
• Figure 1C illustrates an overview schematic diagram in which the signaling system calls listeners after signaling the nodes in a dependency chain in accordance with an implementation of the present invention
• Figure 2 illustrates a flow chart of a method in accordance with an implementation of the present invention for insuring consistency among dependent nodes in a dependency chain
• Figure 3 illustrates a flow chart of a method for creating different dependency chain structures for insuring consistency among nodes in accordance with an implementation of the present invention.
• Implementations of the present invention extend to systems, methods, and computer program products that ensure a synchronized approach to delivering, reporting, and/or otherwise processing status/value changes in complex software dependency chains.
• implementations of the present invention include a two-phase approach in which the system establishes a node graph corresponding to dependency chain of software components, and only calls all listeners in the node graph after all nodes have been signaled.
• implementations of the present invention can ensure that all listeners receive values based on effectively the same state for the relevant source components, and in appropriate order, thus ensuring consistency.
• a directed notification graph provides state change notifications in dependence order (as indicated by graph shape).
• state change (without necessarily passing the changed value) only happens after the program can correctly determine that all out of date nodes are out of date.
• notification only happens once for a given node (which addresses cycles).
• Figure IA illustrates an overview schematic diagram in which a signaling system 100 prepares a node graph for at least one set of dependent software components in a dependency chain, in order to ensure consistent signaling.
• system 100 comprises components A 110, B 120, C 130, D 140, E 150, and F 160.
• Figure IA shows that component A 110 depends on component B 120, and component C, while component B 120 depends on component D 140 and component C depends from component E 150.
• Figure IA shows that component D 140 depends from component F 160, and that component D and component E are conditionally related to each other. For example, component E might only compute a value if a value coming out of component D is of a certain size or length, etc.
• this set of software components A-F can be thought of generally as forming a "dependency chain," which comprises a plurality of source, dependent, and or end-nodes.
• component F 160 can be understood essentially as a source node in the dependency chain.
• components B, C, D, and E can be understood essentially as intermediate nodes, and component A can be understood a dependent node of the dependency chain.
• any given node in a dependency chain can be considered a dependent node, an intermediate node, or a source node with respect to another node in the dependency chain.
• component D 140 can be considered a source node to component B 120 and/or to component E 150.
• component E 150 can be considered a source node to component C 130 and so forth.
• component A could comprise an output module for one particular calculation that involves components B-F in one calculation, but involves more or fewer such component nodes in other calculations.
• Figure IA shows that system 100 can prepare a node graph 113 corresponding to (or otherwise representing) the dependency chain of software components.
• node graph 113 comprises a set of in-memory data structures having linked nodes (110a, 120a, 130a, 140a, 150a, and 160a) that are created and discarded based on state changes in relevant software components (e.g., 110, 120, 130, 140, 150, 160).
• processing module 105 traverses each software component 110, 120, 130, 140, 150, 160 in a dependency chain for the particular request, and prepares a corresponding node graph 113.
• Figure IA shows that processing module 105 prepares a node graph 113 comprising nodes HOa, 120a, 130a, 140a, 150a, and 160a, which correspond respectively to components 110, 120, 130, 140, 150, and 160.
• Figure IA shows that processing module 105 also registers each of the different listeners for each software component in a listener registry 170. For example, upon traversing the various components 110, 120, 130, etc. to identify dependencies, each component can also provide an indication of a particular listener. Processing module 105 can then register each identified listener in a listener registry when identified, and thus in the approximate or exact order in the dependency chain. For example, Figure IA shows that components B 120, D 145, and E 155 each use a listener, such as listeners B 125, D 145, and E 155, respectively.
• Figure IA shows that listener registry 170 comprises a representation for listener D 145, listener E 155, and listener B 125 in relative dependency chain order.
• system 100 can create and discard node graph 113 to reflect and administer changes in software component state.
• processing module 105 may have created this particular node graph 113 when source node F equals a value (e.g., "0", or "state 1" 165).
• source node F changes from a first state to another subsequent state or value (e.g., from "0" to "10" - not shown)
• system 100 e.g., via processing module 105) can then update the node graph 113 to reflect there mere fact that the change has occurred.
• the system 100 can then hold the node graph 113 in this particular state until such time as all components have had a chance to finish any desired processing.
• processing module 105 can then discard node graph 113, and start over with a new such node graph as necessary.
• system 100 essentially forbids the corresponding nodes from receiving a new update in state while the components 110, 120, 130 are processing the prior change (e.g., the change from "0" to "10").
• This consistency and unity in processing in the software component is enabled at least in part using one or more signaling features in accordance with implementations of the present invention.
• Figure IA shows that each of the various nodes 110a, 120a, etc. of node graph 113 comprises (or is prepared with) a binary indicator, such as binary indicators 117a, 127a, 137a, 147a, 157a and 167a.
• the binary indicator is shown as a "+" sign to identify a particular initial or first setting.
• a "+" sign in the illustrated case means the default value of a given software source component (e.g., component 160, state 165) for which the dependency chain is based, and before any changes have been processed.
• node graph 113 can be set up so that a change in binary indicators is linked to a particular state for an original source node. For example, as soon as the change in state of component F 160 was received (i.e., message 180), system 100 can cache the new value (e.g., changed from "0" to "10"), and automatically link the new value to node graph 113, regardless of any other subsequent changes that might occur with source component F 160. Furthermore, system 100 can link any subsequent change to the value of the source component (e.g., component F 160) to a new (or refreshed) node graph (not shown) at such time as required.
• the new value e.g., changed from "0" to "10
• a "binary" indicator can only change to one other value, and, as discussed herein, only one time.
• processing module 105 identifies a change in value to a particular software source component (e.g., 160)
• the binary indicators 117a, 127a, etc. are only updated once to reflect the change.
• Figure IA shows that processing module 105 receives a message 180 indicating that component F 160 has been updated.
• processing module 105 then sends a signal 185 through each of the different nodes 110a, 120a, etc.
• Signal 185 includes a notation to change the binary indicators from "+” status to a "-” status, and thus simply updates the initial setting on a binary indicator to a subsequent setting.
• signal 185 is sent essentially in dependency chain order starting from the source node F 160a.
• Figure IB shows that signal 185 is first sent to node F 160a, then on to nodes D 140a and E 150a, and so on, which results in a change binary indicators from setting 167a, 157a, and 147a (i.e., "+") to settings 167b, 157b, and 147b (i.e., "-”), respectively.
• signal 185 will pass through each dependency until all nodes in node graph 113 receive signal 185. In most cases, each node will only receive the signal one time. Implementations of the present invention, however, can accommodate cases in which a node receives a repeat of the signal (or any other signal) for any other reason, since each binary indicator nevertheless changes "at most once.” [0032] Specifically, since each binary indicator 147 can be changed only one time (i.e., "at most once"), no other signals (or repeats of a signal) can change the binary indicator of a changed/updated node. That is, with specific reference to the terms used in these Figures, once set to the illustrated "-" sign, a given binary indicator cannot be changed back to a "+” sign.
• each node of the node graph 113 is configured at creation with no back- channel to another node.
• node F 160a relays signal 185 at least to node D 140a
• node F 140a cannot accept a return signal from node D 140a.
• System 100 further ensures that no processing within this particular dependency chain can occur until all nodes in a given node graph have been updated (via signal 185).
• system 100 ensures this consistency by holding the calling of listeners 125, 145, or 155 until after all binary indicators have been set and updated, or until after signal 185 has reached all nodes in node graph 113 at least once. In such implementations, therefore, the initial creation of the node graph (e.g., Figure IA) will not result in any processing due to the mere discovery of listeners 125, 145, and 155. Even at the point where system 100 receives an update to component F (e.g., message 180), system 100 will not call any of listeners 125, 145, or 155 until the binary indicators have been updated to reflect the initial change at the source node.
• component F e.g., message 180
• system 100 can further enhance consistency by calling listeners in a particular order.
• Figures IA- 1C shows that the listener registry 170 stores the references to the listeners 125, 145, and 145 in essentially the order they were identified by processing module 105.
• Figures IA- 1C show that listener registry 170 stores the order of these particular listeners in order first of listener D 145, listener E 155, and listener B 125.
• processing module 105 when processing module 105 ultimately calls these particular listeners, processing module 105 only does so in approximate processing order.
• FIG. 1C shows that processing module 105 applies message 190 through the node graph 113 in approximate dependency chain order so that listeners D 145 and E 155 corresponding to nodes D 140a and E 150a are called before listener B 125 corresponding to node B 120a.
• each corresponding software component can perform processing based on the value changes at the source component. For example, once the listener 145 is called, software component D 140 can perform any processing on the cached value associated with this node graph 113 (e.g., the present value of source component F 160).
• component E 150 and B 120 can retrieve any value that has already been processed and/or provided from node D, which is based on the most recent update to component F from message 180.
• system 100 thus orders not only the calling of each listener, but also the processing of successive values along the dependency chain. This significantly increases the likelihood that each value that a particular software component retrieves from another source/intermediate node is based only on an already-processed, most up-to-date value.
• processing module 150 then discards node graph 113. If required, system 100 can prepare another node graph corresponding to yet another change in component F.
• Figure IA, IB and 1C provide one or more schematics or components for ensuring that components in a dependency chain effectively process only one state change in a source node at a time, and essentially in the correct order. This can provide a number of important guarantees, and can mitigate or otherwise eliminate concerns that sometimes arise over race conditions (between processing of current and old values in the same chain) in these particular cases.
• implementations of the present invention can also be described in terms of methods comprising one or more acts for accomplishing a particular result.
• Figure 2 illustrates a flowchart of a method of processing a consistent set of one or more values in a dependency chain.
• Figure 3 illustrates an additional or alternative method of creating and updating in-memory data structures representing the dependency chain based only on a set of guaranteed values.
• the acts in the flowcharts of Figures 2 and 3 are described below with respect to the components and schematics of Figures 1A-1C.
• Figure 2 illustrates that a method of processing a consistent set of one or more values in a dependency chain can comprise an act 200 of identifying nodes in a dependency chain.
• Act 200 includes creating a plurality of nodes corresponding to a plurality of components that include one or more source components and one or more dependent components that are ordered in a dependency chain.
• processing module 105 receives a request for processing from component A I lO, and traverse the corresponding dependency chain to identify each of the different components from which component A depends. Processing module 105 then creates a corresponding node graph 113 data structure comprising one or more nodes in the dependency chain that correlate with the identified components from which A depends.
• Figure 2 also shows that the method can comprise an act 210 of setting binary indicators for each node.
• Act 210 includes, for each node, setting a binary indicator to a first setting that indicates that one or more source components comprise an initial status.
• Figure IA shows that processing module 105 creates and sets a binary indicator 117a, 127a, 137a, 147a, 157a and 167a for each node in node graph 113.
• this particular binary indicator is set to an initial state (165), which effectively clarifies that the value of the one or more source components (e.g., component F 160) from the time of setting up the node graph has/have not yet changed.
• Figure 2 shows that the method can comprise an act 220 of, after the source node changes, setting all binary indicators to a second setting.
• Act 220 includes, upon identifying a change to a subsequent status in the one or more source components, setting each binary indicator for each node to a second setting.
• processing module 105 once processing module 105 identifies a change to node F, processing module 105 immediately begins signaling the change, such as by first changing each of the binary indicators in the node graph 113 to an alternate, subsequent representation.
• Figure IB shows that processing module 105 passes signal 185 to each node in node graph 113, changing the "+" setting to a "-.”
• Figure 2 shows that the method can comprise an act 230 of calling all listeners in the dependency chain.
• Act 230 includes calling one or more listeners that have been registered with the created plurality of nodes, wherein the one or more listeners are synchronized to execute based on the subsequent status in the one or more source components.
• Figure 1C shows that system 100 calls each listener for each component, and does so in the order they were originally identified in the dependency chain (e.g., closest to the source node onward to closest to the end node).
• Figure 1C shows that system 100 first calls listener D 145, then listener E 155, and listener B 125, and so on.
• Figure 3 illustrates that an additional or alternative method in accordance with the present invention for generating a dependency chain based only on a set of guaranteed values can comprise an act 300 of creating a node graph based on a first state.
• Act 300 includes creating an initial node graph corresponding to a plurality of components that include one or more dependent components that depend from one or more source components, wherein each node of the initial node graph is set to a first setting.
• Figure IA shows that processing module 105, upon identifying a processing request 180, traverses components 110, 120, 130, 140, 150, 160 to create a node graph 113 that includes corresponding nodes 110a, 120a, etc.
• processing module 105 further sets a binary indicator (117a, 127a, etc.) in each node to an initial state (i.e., "+"), indicating that node graph 113 is based off of an initial state (165) of the source node component F 160.
• Figure 3 also shows that the method can comprise an act 310 of calling all listeners after the state change has been replicated.
• Act 310 includes, upon identifying that the one or more source components have changed to an updated value, caching the updated value, and initiating all listeners registered for the initial node graph to perform processing based on the updated value.
• Figure IB and 1C show that upon receiving message 180 to update component node F, processing module 105 changes all the binary indicators in an alternate designation, such as 147b, 157b, 167b, etc. in a node graph 113 (i.e., to "-"), and further calls all listeners in registry 170.
• Figure 3 shows that the method can comprise an act 320 of discarding the node graph.
• Act 320 includes discarding the initial node graph after all initiated listeners have finished processing based on the updated value. For example, after each listener shown in Figure 3 has accessed the most recent value available to node graph 113, processing module 105 discards the node graph 113. Since each of the different binary indicators 147b, 157b, etc. can only be changed once, no other subsequent changes into the different components or nodes can be replicated and handled by any of the other called listeners. Thus, system 100 discards the dependency node graph 113.
• Figure 3 shows that the method can comprise an act 330 of creating a new node graph based on an updated state.
• Act 330 includes creating a subsequent node graph based on one or more subsequent changes to the one or more source components.
• processing module 105 could then traverse the set of dependency chains pertaining to this particular processing request again, and identify a new set of nodes pertaining to a new node graph (not shown).
• this new node graph would also be an in-memory data structure, albeit based on a more recent change to the corresponding source nodes.
• the node graph can comprise the same representations as shown in Figure IA, but could also comprise different components or nodes, since the execution context may be different and may have different dependencies.
• this creation of new node graphs and new dependency chains can be continually refreshed, recreated, and discarded as needed.
• implementations of the present invention thus ensure that source node value changes are processed throughout a dependency chain only one time in a particular node graph context, and in a consistent manner. Accordingly, implementations of the present invention can ensure a high degree of accuracy and consistency in value processing, even in very complex dependency chains of software components.
• the embodiments of the present invention may comprise a special purpose or general-purpose computer including various computer hardware, as discussed in greater detail below.
• Embodiments within the scope of the present invention also include computer-readable media for carrying or having computer-executable instructions or data structures stored thereon.
• Such computer-readable media can be any available media that can be accessed by a general purpose or special purpose computer.
• such computer-readable media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to carry or store desired program code means in the form of computer- executable instructions or data structures and which can be accessed by a general purpose or special purpose computer.
• a network or another communications connection either hardwired, wireless, or a combination of hardwired or wireless
• the computer properly views the connection as a computer-readable medium.
• any such connection is properly termed a computer-readable medium.
• Computer-executable instructions comprise, for example, instructions and data which cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions.

Landscapes

• Engineering & Computer Science (AREA)
• Software Systems (AREA)
• Theoretical Computer Science (AREA)
• Multimedia (AREA)
• Physics & Mathematics (AREA)
• General Engineering & Computer Science (AREA)
• General Physics & Mathematics (AREA)
• Stored Programmes (AREA)
• Mobile Radio Communication Systems (AREA)
• Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
• Hardware Redundancy (AREA)
• Telephonic Communication Services (AREA)

Priority Applications (3)

Applications Claiming Priority (2)

Publications (2)

Family

ID=40999338

Family Applications (1)

Country Status (5)

Cited By (1)

Families Citing this family (15)

Family Cites Families (26)

• 2008
  • 2008-02-25 US US12/037,004 patent/US7860900B2/en active Active
• 2009
  • 2009-01-23 WO PCT/US2009/031890 patent/WO2009108427A2/en not_active Ceased
  • 2009-01-23 EP EP09715468A patent/EP2260378A4/en not_active Ceased
  • 2009-01-23 CN CN2009801066431A patent/CN101952799B/zh active Active
  • 2009-01-23 JP JP2010548762A patent/JP5129351B2/ja active Active

Non-Patent Citations (1)

Also Published As

Similar Documents

Legal Events