Definitive reproduction of events between software entities

Abstract

A method and non-transitory computer-readable medium for deterministically reproducing events between software entities is provided. When events are replayed, software entities stimulated by those events are queued according to a queuing strategy and executed from the queue. In an alternative embodiment, when software entities are executed, events output by those software entities are queued according to a queuing strategy and replayed from the queue. Both embodiments guarantee determinism and reproducibility across replays.

Description

Technical Field

[0001] The embodiments described in this specification are generally directed to the reproduction of data, and more particularly, to the deterministic reproduction of events (e.g., data communication) between software entities.

Background Art

[0002] (Description of Related Art) Many frameworks used to develop robotics or automotive systems provide the ability to record and reproduce data communication between software entities within the system. Examples of such frameworks include, but are not limited to, the Robot Operating System (ROS), the Automotive Data and Time Trigger Framework (ADTF), and the Extended Communication Abstraction Layer (eCAL).

[0003] The data to be reproduced may be a recording of inputs in the actual system or synthetic data generated to stimulate the actual system. Reproducing such data to stimulate the system is useful for debugging a particular state of the system in which the data was recorded (e.g., a particular situation experienced by an autonomous or semi-autonomous vehicle), testing the system for its ability to analyze particular situations (e.g., corner cases that are difficult to find in the real world), establishing reproducible tests ( e.g., tests executed in a continuous integration pipeline to check whether each iteration of the system's software reacts in a predefined way when processing a given input), accelerating software development for a particular part of the system (e.g., instead of running the entire system, using specific data related to a particular part of the system, such as data related to a vehicle ​​​​​​(You can select data such as nighttime rain for the weather response system within both systems.) It may be useful for calling / or similar purposes.

[0004] In many cases, this involves reproducing data from only a single software entity, or hundreds of software entities. From recreating all the data of a massive system with a physical wearable entity to recreating it at a different level. It is reproducible. Normally, messages during data communication between software entities are recorded. The events are reproduced in the order they occurred in the recording. If a message contains a timestamp, the time Timestamps can be used to recreate messages in sequence. In many cases, The reproduction speed can be made slower or faster relative to real time.

[0005] When reproducing the data, one or more software entities are executed in one or parallel execution mode. It can be stimulated to run in Red. However, the hardware on which the data is reproduced The environment may differ from the hardware environment in which the data was recorded. For example, in a vehicle The data recorded from the installed electronic control unit (ECU) was stored on the developer's laptop. This can sometimes be reproduced in hardware environments or cloud-based environments. Because the software in the development environment may have changed compared to the software in the recording environment. The runtime behavior during reproduction may differ from the runtime behavior during recording. Also, the same operator A background task running on the testing system coincides with the timing of the task being reproduced. Runtime behavior may differ between various reproductions, including influencing the outcome. Runtime behavior can lead to variations in the execution order of software entities and issues with the start of reproducibility. Variation in the start and end points of the execution of the software entity, and the software entity's response to the start of reproduction. Variations in the timing of the body outputting or consuming messages, and related to the reproduced messages. The variability of the input processed by the software entity, and the messages sent by other software entities. Regarding Sage, the variability of the inputs processed by the software entity and the output of the software entity Variations such as those mentioned may occur. As a result of all these variations, The results of the reproduction cannot be regenerated. Such non-deterministic runtime behavior of reproduction is software It increases as the number of share entities and the number of parallel threads running increase.

[0006] Furthermore, data-driven approaches are typically seen in robotics and modern automotive applications. In type execution, there are more indeterminists than are typically present in purely time-driven applications. This occurs because the software entity sends messages at various times. This is so that it will be sent. As a result, the software that receives these messages will be stimulated. The software will start execution at various start times. In many cases, the receiving side will... When the execution of a software entity begins, messages from multiple sending software entities are sent. The group is consumed by the communication middleware. As a result of the nondeterminism described above, this message group It is indeterminate, and therefore the output that the software entity generates from these messages is also It is also uncertain.

[0007] As a result, it is impossible to establish reproducible tests with conventional frameworks. Even if it's not possible, it is difficult. This difficulty stems from the fact that the system under test uses a multi-core processor. If implementing a graph of software entities executed in a, it will further increase. That is , in this case, advanced technologies and efficiency improvements in the hardware environment can prevent the reproducibility of reproduction.

Summary of the Invention

[0008] Therefore, regardless of the number of software entities, the number of execution threads, and the usage of multi-core processors , a system, method, and non-transitory computer-readable medium are disclosed that provide a deterministic reproduction of events that are reproducible and suitable for all hardware environments.

[0009] In a first embodiment, a method for reproducing the recording of events between a plurality of software entities within a system using at least one hardware processor is disclosed, and for each of one or more events in the recording, the following is included. A step of reproducing the event, a step of putting all software entities stimulated by the event into a queue, a step of deleting and executing the software entity at the head of the queue until the queue is empty, a step of reproducing all events output by the executed software entity, and a step of putting all software entities stimulated by the reproduced events output by the executed software entity into the queue. Each step of reproducing an event may include a step of sending a message representing the event. This method uses at least one hardware processor to ensure that no event is reproduced during the execution of any of the plurality of software entities. It may also be included. This method uses at least one hardware processor to multiplex It may further include ensuring that no other software entity is executed during the execution of any of the other software entities among the multiple software entities. The system may be a subsystem of a vehicle or a robot

[0010] Each step of putting a software entity into the queue may include inserting the software entity into the queue if the software entity does not already exist at any position within the queue, and not inserting a duplicate of the software entity into the queue when the software entity already exists at a certain position within the queue. Inserting a software entity into the queue may include inserting the software entity at the end of the queue. Alternatively, inserting a software entity into the queue may include inserting the software entity at the head of the queue.

[0011] Each step of putting a software entity into the queue may include inserting the software entity into the queue regardless of whether the software entity already exists at a certain position within the queue. Inserting a software entity into the queue may include inserting the software entity at the end of the queue. Also, inserting a software entity into the queue may include inserting the software entity at the head of the queue.

[0012] In a second embodiment, a method of reproducing the recording of events between multiple software entities within a system using at least one hardware processor, wherein within the recording ​​​​​​​​​​​​For each of one or more events, a method is disclosed which includes the following: Restart the event The steps that are revealed, and the execution of all software entities triggered by the events. The step and all events output by any of the executed software entities are monitored. The steps involve adding events to the queue and removing the event at the front of the queue until the queue is empty. The steps involve reproducing the event and then removing the reproduced event from the front of the queue. The steps to execute all software entities that are being triggered, and remove them from the front of the queue. By any of the executed software entities stimulated by the reproduced event The steps are to put all the output events into a queue and then reproduce the events. Each step may include sending a message representing the event. Each step of adding an event to the queue is performed if the event is already present at any position in the queue. If not present, insert the event into the queue, and the event is located at a certain position in the queue. This may include not inserting a duplicate of the event into the queue if it already exists. Alternatively, each step of adding an event to the queue is when the event reaches a certain position in the queue. This may include inserting the event into the queue, regardless of whether it already exists or not. i. Events that are triggered or reproduced by events that have been removed from the front of the queue. The steps that execute all software entities, stimulated by the signal, are all The system may include a step of executing software entities in parallel. It could also be a subsystem of the system.

[0013] These methods are executable software for processor-based systems such as servers. Modules and / or executable instructions stored on non-temporary computer-readable media It can be materialized in this way. [Brief explanation of the drawing]

[0014] Details of the present invention relate to both its structure and operation, and similar parts have similar reference numerals. This can be partially obtained by studying the attached drawings. [Figure 1] Figure 1 shows an exemplary processing system in which one or more of the processes described herein may be performed according to one embodiment. [Figure 2] Figure 2 shows an exemplary graph illustrating the reproducible system operation according to one embodiment. [Figure 3] Figure 3 shows an algorithm for reproducing data by placing stimulated software entities into a queue, according to the first embodiment. [Figure 4A] Figure 4A shows a variation of the queueing strategy for the first embodiment of the algorithm, according to an embodiment. [Figure 4B] Figure 4B shows a variation of the queueing strategy for the first embodiment of the algorithm, according to the embodiment. [Figure 4C] Figure 4C shows a modified version of the queueing strategy for the first embodiment of the algorithm, according to an embodiment. [Figure 5] Figure 5 shows an algorithm for reconstructing data by placing events into a queue, according to the second embodiment. [Figure 6A] Figure 6A shows a variation of the queueing strategy for a second embodiment of the algorithm, according to the embodiment. [Figure 6B] Figure 6B shows a variation of the queueing strategy for a second embodiment of the algorithm, according to the embodiment. [Figure 6C]Figure 6C shows a variation of the queueing strategy for a second embodiment of the algorithm, according to the embodiment. [Modes for carrying out the invention]

[0015] In one embodiment, a system and method for definitively reproducing events between software entities. , and non-temporary computer-readable media are disclosed. After reading this description, those skilled in the art will know Methods for carrying out the present invention in various alternative embodiments and alternative applications. This will become clear. However, various embodiments of the present invention are described herein. However, these embodiments are presented for illustrative and explanatory purposes only and are not intended to limit the scope of this work. This will be understood. Thus, this detailed description of various embodiments is attached to the Patent Application. The scope of the request should not be construed as limiting the scope or extent of the invention as defined. .

[0016] (1. System Overview) Figure 1 shows an exemplary wired or This is a block diagram of wireless system 100. For example, system 100 is as shown herein. Describe (for example, one or more software entities, codecs described herein) Functions for storing and / or running a generator or other software module. To use as one or more of a process or method, or in connection therewith. This is possible. System 100 can also be used as a server, a conventional personal computer, or a robot. This could be a control system within the vehicle, or any other processor-enabled device. As is obvious, it uses other computer systems and / or architectures It is also possible.

[0017] The system 100 preferably includes one or more processors 110. The 110 may include a central processing unit (CPU). Additional processors, for example, image processors. Processing unit (GPU), auxiliary processors that manage input / output, floating-point mathematical operations It has an auxiliary processor for execution and an architecture suitable for high-speed execution of signal processing algorithms. Special-purpose microprocessors (e.g., digital signal processors), main processing systems A slave processor (e.g., backend processor) that is dependent on it, dual or Additional microprocessors or controllers for multiprocessor systems, and / Alternatively, a coprocessor or the like may be provided. Such an auxiliary processor is a separate program. It may be a separate processor or may be integrated with the processor 110. Together with the system 100 Examples of processors that may be used include, but are not limited to, the "Pentium®" processor. Sessa has developed "Core i7" and "Xeon®" processors. Including these, all are available from Intel Corporation in Santa Clara, California. .

[0018] The processor 110 is preferably connected to the communication bus 105. The communication bus 105 is A data channel to facilitate information transfer between the storage device of system 100 and other peripheral components. Channels may also be included. Furthermore, the communication bus 105 includes a data bus, an address bus, and / or a signal set used for communication with the processor 110, including a control bus (not shown). A set may be provided. The communication bus 105 is, for example, an industry standard architecture (ISA). Extended Industry Standard Architecture (EISA), Microchannel Architecture (MCA) ), Peripheral Components Interconnection (PCI) Local Bus, "IEEE488" General Purpose Interface Bus (GPIB), "IEEE696 / S-100", and / or similar. Any standard or non-standard batteries, such as standards popularized by the Institute of Electrical and Electronics Engineers (IEEE) It may be composed of a S architecture.

[0019] System 100 preferably includes a main memory 115 and a secondary memory 120. That is also acceptable. The main memory 115 contains one or more functions and / or modules discussed herein. Instructions and data storage for programs that run on processor 110, such as a log. The device provides a program that is stored in memory and executed by the processor 110. While not limited to "C / C++", "Java", "JavaScript", "PE Follow any appropriate language, including "rl", "Visual Basic", and ".NET". You should understand that you can write and / or compile it as follows: Main memory 115 typically refers to dynamic random access memory (DRAM) and / or static random access memory. It is a semiconductor-based memory such as solid access memory (SRAM). The memory types include, for example, synchronous dynamic random access memory (SDRAM), Rambus Dynamic Random Access Memory (RDRAM), Ferroelectric Random Access Memory This includes FRAM (registered trademark) and read-only memory (ROM), etc.

[0020] The secondary memory 120 optionally includes an internal medium 125 and / or a removable medium 130. It may include: The removable medium 130 is read by any well-known method and / or or is written. The removable storage medium 130 is, for example, a magnetic tape drive, Compact disc (CD) drives, digital multi-purpose disc (DVD) drives, and other optical drives. This may be a drive, flash memory drive, and / or similar device.

[0021] Secondary memory 120 contains computer executable code (for example, open Non-temporary computers containing the indicated software module and / or other data It is a readable medium. Computer software stored in secondary memory 120 and The data is loaded into main memory 115 for execution by processor 110.

[0022] In another embodiment, the secondary memory 120 also contains computer programs or other data. This includes other similar means for enabling the loading of instructions into system 100. However, that is also acceptable. Such means include, for example, software and data on an external storage medium 145 It may also include a communication interface 140 that allows transfer from to system 100. Examples of external storage media 145 include external hard disk drives, external optical drives, and external This may include a magneto-optical drive and / or similar devices. Other examples of secondary memory 120 This refers to programmable read-only memory (PROM), and erasable programmable read-only memory. Read-only memory (EPROM), electrically erasable read-only memory (EEPROM) , and semiconductor memory such as flash memory (block-oriented memory similar to EEPROM) It could be memory.

[0023] As described above, system 100 may include a communication interface 140. Interface 140 connects system 100 to external devices (e.g., printers) and networks. It enables the transfer of software and data between or to other information sources. For example, computer software or data is transmitted via the communication interface 140. , from a network server to one or more networks (for example, the internet) The data (including) may be forwarded to system 100. An example of a communication interface 140 is Built-in network adapter, network interface card (NIC), personal Computer Memory Card International Association (PCMCIA) Network Card, Cardbus Network adapters, wireless network adapters, Universal Serial Bus (USB) ) Network adapter, modem, wireless data card, communication port, infrared interface The "IEEE1394" FireWire system 100 and network or another network This includes any other device capable of interfacing with a computer device. Face 140 preferably uses the Ethernet "IEEE 802" standard, Fibre Channel. Digital subscriber line (DSL), asynchronous digital subscriber line (ADSL), frame relay Asynchronous transfer mode (ATM), Integrated Digital Service Network (ISDN), Personal Communication services (PCS), Transmission Control Protocol / Internet Protocol (TCP / I P), Serial Line Internet Protocol / Point Protocol (SLIP / PP) Implement industry-wide protocol standards such as P), but with custom or non-standard features. An interface protocol may be implemented.

[0024] The software and data transferred via the communication interface 140 are generally: These are telecommunication signals 155 in form. These signals 155 are transmitted via the communication channel 150. It may be provided to the communication interface 140. In one embodiment, the communication channel 150 This may be a wired or wireless network, or any other type of communication link. The communication channel 150 carries the signal 155, and to give a few examples, it can be a wire or Cables, fiber optics, conventional telephone lines, cellular telephone links, wireless data communication links, Various wired or wireless communications, including radio frequency ("RF") links or infrared links. It can be implemented using communication methods.

[0025] Computer executable code (for example, one or more software modules) The computer program (and others) is stored in main memory 115 and / or secondary memory 120. It is stored. The computer executable code is received via the communication interface 140. It is also possible to store this in the main memory 115 and / or the secondary memory 120. When such computer executable code is executed, system 100 will execute other code specified herein. Various functions of the disclosed embodiments, as described in the section above, can be performed.

[0026] In this specification, the term "computer-readable medium" refers to computer executable code. To provide and / or other data to or within system 100 It is used to refer to any non-temporary computer-readable storage medium used. Examples of such media include main memory 115, secondary memory 120 (internal memory 125, removable (including the available media 130 and the external storage medium 145), and the communication interface 140 Any peripheral device (network information server or other network) that is connected to it in a communicative manner (network information server or other network Examples include workpieces. These non-temporary computer-readable media are executable. The system can use code, programming instructions, software, and / or other data. This is a means to provide 100.

[0027] In embodiments implemented using software, the software is a computer-readable medium A removable medium 130 is housed in the body, and an input / output (I / O) interface 135 is located within it. Alternatively, it can be loaded into system 100 via communication interface 140. In such an embodiment, the software sends a telecommunications signal 155 to the system 100. The software is loaded. When the software is executed by the processor 110, preferably The processor 110 has one of the processes and functions described elsewhere in this specification. To execute one or more actions.

[0028] In this embodiment, the I / O interface 135 is one or more of the system 100. The interface between a number of components and one or more input and / or output devices Provided. Examples of input devices include, but are not limited to, sensors, keyboards, and touchscreens. or other touch-sensitive devices, cameras, biosensors, computer mice, trackers Including balls, pen-type pointing devices, and / or similar devices. Output devices Examples include, but are not limited to, other processing equipment, cathode ray tubes (CRTs), plasma displays. I. Light-emitting diode (LED) displays, liquid crystal displays (LCDs), printers, Vacuum fluorescence displays (VFDs), surface conduction electron emitter displays (SEDs), electric fields Examples include emission displays (FEDs) and / or similar devices. , touch panel display (for example, smartphone, tablet, or other mobile In some cases, such as with a multi-device setup, input and output devices may be combined.

[0029] System 100 wirelessly transmits data over a voice network and / or data network. It may also include any wireless communication components that facilitate communication. Wireless communication components include antennas. It includes a stem 170, a wireless system 165, and a baseband system 160. In system 100, radio frequency (RF) signals are controlled by the radio system 165. The signal is transmitted and received in the air by the antenna system 170.

[0030] In one embodiment, the antenna system 170 includes one or more antennas and The switching function is performed to provide transmit and receive signal paths to the Tena System 170. It may include one or more multiplexers (not shown). In the receiving path, the receiving R The F signal is received from the multiplexer, the RF signal is amplified, and the amplified signal is sent to the wireless system 1 It can be coupled to a low-noise amplifier (not shown) that transmits to 65.

[0031] In another embodiment, the wireless system 165 is configured to communicate at various frequencies. It may include one or more wireless devices. In one embodiment, the wireless system 165 This combines a demodulator (not shown) and a modulator (not shown) into a single integrated circuit (IC). It is possible. Also, the demodulator and modulator may be separate components. The demodulator then strips away the RF carrier signal, leaving the baseband received audio signal. This is transmitted from the wireless system 165 to the baseband system 160.

[0032] If the received signal contains voice information, the baseband system 160 will transmit that signal It decodes the signal and converts it to an analog signal. Then, it amplifies the signal and sends it to the speaker. Also, The baseband system 160 receives analog audio signals from the microphone. These analog audio signals are then converted to digital signals by the baseband system 160. It is converted to a number and encoded. The baseband system 160 also uses digital for transmission. The baseband transmission signal is encoded and routed to the modulator portion of the wireless system 165. It generates an audio signal. The modulator transmits the baseband audio signal as an RF carrier signal. It is mixed with and routed to the antenna system 170 and passes through a power amplifier (not shown). It generates an RF transmission signal that can be used. The power amplifier amplifies the RF transmission signal and turns it into an amplifier. The signal is routed to the Tena System 170, where it is switched to the antenna port for transmission. It can be done.

[0033] The baseband system 160 is also communicatively coupled to the processor 110. The processor 110 can access the data storage areas 115 and 120. The processor 110 preferably stores in the main memory 115 or the secondary memory 120. Instructions that can be used (i.e., computer programs such as disclosed applications) It is configured to run a computer (or software module). The program is received from the baseband processor 160 and stored in the main memory 110 or This can be stored in secondary memory 120, or it can be executed upon reception. When such a computer program is executed, system 100 will, according to the disclosed embodiment It can perform a variety of functions.

[0034] (2. Process Overview) Next, regarding embodiments of the process for definitively reproducing events between software entities... I will explain in detail. The process I will explain is, for example, a computer program or software. As a software package, one or more hardware processors (e.g., processors) embodied in one or more software modules executed by (S110) You should understand what is possible. The process to explain is the source code, of It can also be implemented as instructions represented in eject code and / or machine code. These instructions may be executed directly by the hardware processor 110, or A virtual machine that operates between object code and hardware processor 110 It can also be executed by [a specific method / tool].

[0035] Alternatively, the process being described involves hardware components (e.g., general-purpose processors, integrated circuits). ICs (integrated circuits), application-specific integrated circuits (ASICs), digital signal processors (DSPs), Field-programmable gate array (FPGA) or other programmable logic device (Placement, individual gates or transistor logic, etc.), combinations of hardware components, It can be implemented as a combination of hardware and software components. To clearly demonstrate the interchangeability between hardware and software, various exemplary components are shown. Blocks, modules, circuits, and steps are generally referred to in this specification from the standpoint of their functionality. I will explain this in writing. Should such a function be implemented as hardware, or as software? Whether or not to install it depends on the specific application and design constraints imposed on the entire system. Therefore, it is possible to implement the described features in various ways for each specific application. However, such a decision to implement the invention should be interpreted as causing a departure from the scope of the present invention. There is no. Furthermore, the grouping of components, blocks, modules, circuits, or functions within a step The phrasing is for the purpose of facilitating explanation. Specific functions or steps are derived from the present invention. Without deviation, from one part, block, module, circuit, or step to another It can be moved to an object.

[0036] Furthermore, the processes described herein are illustrated by the specific arrangement and order of the subprocesses. However, each process has fewer, more, or different subprocesses, and The process can be carried out in different arrangements and / or sequences. Furthermore, the subprocess Even if described or illustrated in a specific order, the task is independent of the completion of other subprocesses. A subprocess can run before, after, or in parallel with other independent subprocesses. We should also understand that this is a good thing.

[0037] (2.1. Introduction) Ensuring that all reproductions of recorded events across software entities lead to the same results. An embodiment of the algorithm is disclosed. A specific state such as the internal state of a software entity. If the behavior cannot be reproduced, the reproduction results may differ from the results of the system on which the data was recorded. It has the property. However, it performs fixed calculations and (for example, with other software entities) fixed A fixed set of software entities having defined interfaces and connections This means that any reproduction can be regenerated. This allows the hardware of the system performing the reproduction to This enables reproducible testing that is independent of the software environment and runtime behavior.

[0038] In one embodiment, this reproducibility is triggered by the software that is stimulated by the reproduced event. This is achieved by using a coordinator that controls the input and execution order of entities. Non-determinism is that while a software entity is running, messages sent to the software entity are not sent. It guarantees that it will not be trusted and that there is a defined order in which the software entities will be executed. This can be avoided by providing proof. This involves (1) preparing the coordinator to execute. This puts a ready software entity into a queue, and only one software entity at a time When executed, the software entity is executed when multiple software entities are stimulated. (2) Ensure there is a set order, or (3) Reproduce to the coordinator (e.g., send or (Transfer) A software entity that queues ready events and executes them in parallel. There is a defined order in which the events output by one entity are sent to other software entities. By guaranteeing that no events are sent while the software entity is running, It can be implemented in this way.

[0039] In one embodiment, the software entity is located on a single system 100 (for example, one Alternatively, one or more processors 110, which may include multiple multi-core processors They can perform actions (such as) or communicate with each other (for example, via wired or wireless communication). It may be distributed across multiple systems 100. Furthermore, the coordinator is Software that runs on the same system 100 as one, more, or all of the software entities. It could be a software module, or a system or system on which the software entity runs. A separate device from Tem100, and which communicates with them (for example, via wired or wireless communication). It may also be executed on system 100. In any case, the coordinator, Stimulate the software entity using input events according to the disclosed algorithm. .

[0040] The algorithm is a software that is stimulated by events recorded in the data being reproduced. These events affect the software entity. These events are sent by other software entities. This may include receiving a message, or it may be a timer event (for example, timer expiration). The stimulus for a software entity is to process an input event (e.g., a message). This includes executing one or more modules of a software entity, which is a form of other software. Additional events (e.g., messages) sent to and consumed by software entities are potentially To generate (for example, a message from a stimulated software entity to another software entity) (By sending this), other software entities are stimulated, and further so This could potentially continue with generating additional events that stimulate the software entity, and so on. .

[0041] In one embodiment, the coordinator determines when to reproduce (e.g., send) the event. , and / or when to execute the software entity (i.e., when to trigger an input event) It controls how to process the software entities that are running. For example, the coordinator controls how to process the software entities that are running. It intercepts all events output by and those events are running in the software It can be prevented from being sent to other software entities by the software entity. The coordinator then reproduces those events at a time selected according to an algorithm (e.g., For example, it can be sent. Furthermore, or the coordinator can use software It communicates with the entity to determine when the software entity will execute (for example, waiting for input events). The coordinator may control whether to process the software entity. It can be guaranteed that it will only run at the time selected according to the algorithm.

[0042] The patterns of behavior or stimuli within a system are represented by nodes (software entities) and edges (events). It can be visually represented as a graph. Figure 2 shows the reproduced system according to the embodiment. An example graph illustrating the behavior of the stem is shown. This illustrative graph is for system 250. This explains the differences between various embodiments of the algorithm for reproducing the recorded data 200. For clarity, as used herein. For simplicity, software entities are simply referred to as "entities[ We will refer to events as "event[character]" instead of "number". So, record 200 begins with event A, which is input to entity 1 and entity 2. Entity 1 is event Stimulated by event A, it outputs events B and C, and entity 2 responds to event A This stimulates and outputs event D, and event B stimulates entity 3 and outputs event E. Events C and D stimulate entity 4 and output event F, while entity 5 triggers events B and D. Stimulated by E and F but does not output an event (or outputs an event but does not output an event) (The record 200 is either not recorded or cannot be reproduced.)

[0043] Each software entity is designed to perform individual functions based on one or more inputs. Please understand that it may include software modules configured in the following example. The software entity that is recorded and / or stimulated during playback is also a robot. It drives the sensor system or control system of a vehicle (e.g., an autonomous or semi-autonomous vehicle). This is also possible. As a non-limiting example, entity 1 and entity 2 are each from separate sensors. , or separate filters that receive messages consisting of point clouds. Entity 1 and Entity Step 2 preprocesses each point cloud to remove unnecessary information or noise. The pre-processed point clouds can be output as Event C and Event D, respectively. Entity 4 performs sensor fusion to merge the point clouds of events C and D into a composite point cloud. The process can be executed, and the composite point cloud can be output as event F. Entity 5 is event F (example). For example, you can receive a message containing a composite point cloud and apply clustering to the composite point cloud. In this case, system 250 is part of the perception system in the driving system of an autonomous vehicle. It can represent a complete system such as an autonomous vehicle driving system, which has various functions (e.g.) For example, point cloud processing, acquisition of speed and other vehicle information, management of object lists, etc. It includes many such subsystems, each subsystem containing many software entities It is important to understand that this can trigger many events. Reproducibility is possible across the entire system, and This applies only to the parts of the system that are of interest (e.g., one or more subsystems). It can be executed.

[0044] (2.2. First Embodiment of the Algorithm) Figure 3 shows the process of placing the stimulated software entity into a queue according to the first embodiment. Algorithm 300 is shown for reproducing the data. Algorithm 300 is a system Execution of software entities and reproduction of events (e.g., sending events to software entities) ) and a coordinator manages the queue of stimulated software entities. Therefore, please understand that it can be executed. The coordinator is a software entity. The same system 250 that performs the operation, or one of the systems 100 that communicate with it. It can be executed by multiple processors 110.

[0045] Initially, the coordinator will focus on the software entities and events within the system being reproduced. Reproducible, including connections to (for example, messages sent via communication middleware) The system topology can be learned. That is, the coordinator can learn the topology of the system shown in Figure 2. It is possible to import system graphs like the one visualized in the example. The configuration is entered into by the coordinator or accessed by the coordinator. It can be obtained or built from a file. Alternatively, the coordinator can use any appropriate mechanism. You can use Zoom to query this information from the reproduced system. Similarly, each software Events input to a software entity and / or output by each software entity. Events can also be obtained from configuration files or queried from the system being reproduced.

[0046] In subprocess 310, algorithm 300 checks if there is a next event to reproduce. Determine whether or not. If the next event that can be reproduced (i.e., in subprocess 310) If the answer is "Yes", then algorithm 300 will perform the following actions in subprocess 320 Reproduce. Otherwise, if there is no next event to reproduce (i.e., subprocess) If the answer to step 310 is "No", then algorithm 300 may terminate. Therefore, Rhythm 300 will play any initial event and during the playback until there are no more events to reproduce. Each event in record 200 includes any event output by the software entity. Please understand that this is an attempt to reproduce the same thing.

[0047] In subprocess 320, algorithm 300 reproduces the following event: Reproducing an event means that any software entity that consumes an event as input will have an event This may include sending or forwarding an event as a message. The event will delete the event. Send to the specific software entity that consumes it, or blow to all software entities. By casting, the software entity can decide for itself whether or not to consume the event. In any case, any event may be consumed by a single software entity. Yes, it may be consumed by multiple software entities, and which software entity Therefore, it does not need to be consumed. The software entity that consumes the event takes that as input. They are "stimulated" by the event.

[0048] In subprocess 330, algorithm 300 is reproduced in subprocess 320. All software entities (if any) stimulated by the event are placed into a queue. This does not require adding the actual software entity to the queue. Please understand that this is not about adding or inserting software entities into a queue. When discussed in a specification, this refers to an identifier or identifier for a software entity. This includes situations in which a reference to is added to or inserted into a queue. Stimulated software entity It can be added to the queue according to various strategies. Some of these strategies This will be discussed below with reference to Figures 4A-4C, as a modified example of the first embodiment. The important point is that the queue is stimulated software that can be reproduced across multiple replays. The objective is to provide ordering of share entities. Also, in some cases, subprocess 320 The events reproduced in this context do not stimulate any software entities, and as a result, In process 330, there may be cases where no software entities are inserted into the queue. Please understand this.

[0049] In subprocess 340, algorithm 300 checks whether the queue is empty. Or, conversely, determine whether there are any stimulated software entities remaining in the queue. If the queue is empty (i.e., "Yes" in subprocess 340), then Lugorhythm 300 returns to subprocess 310, and any event remains in record 200. It will decide whether or not to do so. Otherwise, at least one stimulated software entity will If it remains in the queue (i.e., it is "No" in subprocess 340), Algorithm 300, in subprocess 350, the next software process in the queue Execute the body.

[0050] In subprocess 350, the following software entity in the queue is removed from the queue. It is then executed. In particular, the software entity is reproduced as input in subprocess 320. It is executed to process incoming events. For example, a software entity executes an input event. The data in the message representing zero, one, or multiple is parsed and processed. It is possible to generate output events. Each output event is linked to one or more other software It can be represented as another message sent to the wear entity. The coordinator enters Using force events to invoke software entities or trigger them in other ways This allows control over the execution of any given software entity within system 250. In response, it can receive output events.

[0051] In subprocess 360, algorithm 300 is executed in subprocess 350. All events (if any) output by the software entity, one or It sends to multiple other software entities. Specifically, for example, these events are sent to 1 It can be transferred to one or more other software entities, or to multiple software entities. Broadcast to entities (for example, all software entities in System 250) It is possible. Next, algorithm 300 returns to subprocess 330 and subprocess Any software entity triggered by an event sent via S360 is placed in a queue. Insert. In some cases, the software entity executed in subprocess 350 is No events were output, and as a result, no events were sent in subprocess 360. Please understand this.

[0052] In summary, in this first embodiment represented by algorithm 300, the following is performed: The software entity (that is, stimulated by the reproduced event) enters the queue. The order in which software entities are placed in the queue is such that the same order is the same for all. As long as it can be reproduced, it can be implemented according to various strategies. When the entity is executed, it outputs additional events that are sent to other software entities to stimulate them. It is possible. Each stimulated software entity is added to the queue according to the selected strategy. When the queue is empty, the coordinator triggers a replay of the next event from the records. The software entity has already entered the queue as a result of prior stimulation by the first event. If, while this is happening, the software entity is triggered again by a second event, Insert into the column again (i.e., perform the first operation for the first event and the second operation for the second event) (to perform a second time) or the software entity has a single position in the queue at once Do not reinsert so that it exists only in the first instance (i.e., perform only once and the first instance of It can either process both the vent and the second event simultaneously.

[0053] Variations of the strategy for adding software entities to a queue in Algorithm 300 Examples are shown in Figures 4A-4C. However, these strategies are non-exclusive examples, and other strategies are possible. Please understand that this is Noh theater.

[0054] (2.2.1. First modified example of the first embodiment) Figure 4A shows the operation of algorithm 300 with a first modification of the queueing strategy. This demonstrates that in this first modified example, the coordinator 400 has a software entity waiting in queue 4 Regardless of whether they already exist elsewhere within 10, each newly stimulated software entity Insert the body to the end of queue 410. Therefore, each event is determined by that event. This involves putting all stimulated software entities into a queue and executing them. Therefore, Coordinator 400 reproduces Record 200 as follows:

[0055] (1) First, reconstruct event A from recording 200 (e.g., subprocess 320). In other words, Coordinator 400 sends Event A, and Event A is Entity 1 and Entity 2 stimulates. Therefore, the coordinator 400 puts entity 1 and entity into the queue 410. Insert body 2 (for example, subprocess 330). The event described herein is re In each of the examples presented, the event can be reproduced by Coordinator 400. Please understand that the event could proceed without the support of Coordinator 400 (for example) However, as is the case during normal operation, it is merely a software entity that outputs an event. It may be reproduced (by line).

[0056] (2) Next, the coordinator 400 executes entity 1 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 1 experiences events B and C It outputs and is reproduced (for example, subprocess 360). In other words, event B and event Event C is sent as a message. Event B stimulates entities 3 and 5. Event C stimulates entity 4. Therefore, coordinator 400 enters queue 41. Insert entities 3, 5, and 4 at the end of 0 (for example, subprocess 330) ).

[0057] (3) Next, the coordinator 400 executes entity 2 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 2 outputs event D and then It is expressed (for example, subprocess 360). In other words, event D is sent as a message. Event D stimulates entities 4 and 5. Therefore, Coordinator 40 0 inserts entities 4 and 5 at the end of queue 410 (for example, subprocess 330).

[0058] (4) Next, the coordinator 400 executes entity 3 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 3 outputs event E and then It is expressed (for example, subprocess 360). In other words, event E is sent as a message It is believed. Event E stimulates entity 5. Therefore, coordinator 400 waits. Insert entity 5 at the end of matrix 410 (for example, subprocess 330).

[0059] (5) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, insertion into queue 410 will not occur.

[0060] (6) Next, the coordinator 400 executes entity 4 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 4 outputs event F and then It is expressed (for example, subprocess 360). In other words, event F is sent as a message It is believed. Event F stimulates entity 5. Therefore, coordinator 400 waits. Insert entity 5 at the end of matrix 410 (for example, subprocess 330).

[0061] (7) Next, the coordinator 400 executes entity 4 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 4 outputs event F and then It is expressed (for example, subprocess 360). In other words, event F is sent as a message It is believed. Event F stimulates entity 5. Therefore, coordinator 400 waits. Insert entity 5 at the end of matrix 410 (for example, subprocess 330).

[0062] (8) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, insertion into queue 410 will not occur.

[0063] (9) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, insertion into queue 410 will not occur.

[0064] (10) Next, the coordinator 400 executes the entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, no insertion into queue 410 will occur.

[0065] (11) Next, the coordinator 400 executes the entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, no insertion into queue 410 occurs. Furthermore, after this execution, queue 41 0 is empty (for example, "Yes" in subprocess 340), and the event remains in log 200. It is not (for example, subprocess 310 is "No"). Therefore, Coordination Process 400 has completed the reproduction of record 200 (for example, process 300 has finished).

[0066] (2.2.2. Second variation of the first embodiment) Figure 4B shows the operation of algorithm 300 with a second variation of the queueing strategy. This second variation shows that the coordinator 400 has a software entity waiting in queue 4 Each newly stimulated software entity queues unless it already exists in one of the other 10 locations. Insert at the end of 410, and if it already exists, duplicate the software entity of queue 410. To prevent this, do not insert a software entity into queue 410. Therefore, Cody The Neta 400 reproduces record 200 as follows:

[0067] (1) First, reconstruct event A from recording 200 (e.g., subprocess 320). In other words, Coordinator 400 sends Event A, and Event A is Entity 1 and Entity 2 stimulates. Therefore, the coordinator 400 puts entity 1 and entity into the queue 410. Insert body 2 (for example, subprocess 330).

[0068] (2) Next, the coordinator 400 executes entity 1 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 1 experiences events B and C It outputs and is reproduced (for example, subprocess 360). In other words, event B and event Event C is sent as a message. Event B stimulates entities 3 and 5. Vent C stimulates entity 4. Therefore, coordinator 400 enters queue 410. Insert entities 3, 5, and 4 at the end (for example, subprocess 330). .

[0069] (3) Next, the coordinator 400 executes entity 2 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 2 outputs event D and then It is expressed (for example, subprocess 360). In other words, event D is sent as a message. Event D stimulates entities 4 and 5. However, entities 4 and 5 are waiting. It already exists in queue 410. Therefore, no insertion into queue 410 will occur.

[0070] (4) Next, the coordinator 400 executes entity 3 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 3 outputs event E and then It is expressed (for example, subprocess 360). In other words, event E is sent as a message It is believed. Event E stimulates entity 5. However, entity 5 is already in queue 410. It exists. Therefore, insertion into queue 410 will not occur.

[0071] (5) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, insertion into queue 410 will not occur.

[0072] (6) Next, the coordinator 400 executes entity 4 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 4 outputs event F and then It is expressed (for example, subprocess 360). In other words, event F is sent as a message It is believed. Event F stimulates entity 5. Therefore, coordinator 400 waits. Insert entity 5 at the end of matrix 410 (for example, subprocess 330).

[0073] (7) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, no insertion into queue 410 occurs. Furthermore, after this execution, queue 410 It is empty (for example, "Yes" in subprocess 340), and the event remains in log 200. It is not (for example, it is "No" in subprocess 310). Therefore, coordination Task 400 has completed the reproduction of record 200 (for example, process 300 has finished).

[0074] (2.2.3. Third Modification of the First Embodiment) Figure 4C shows the operation of algorithm 300 with a third variation of the queueing strategy. This third variation shows that the coordinator 400 has a software entity waiting in queue 4 Each newly stimulated software entity queues unless it already exists in one of the other 10 locations. Insert at the beginning of 410, and if it already exists, duplicate the software entity in queue 410. To prevent this, do not insert a software entity into queue 410. Therefore, Cody The Neta 400 reproduces record 200 as follows:

[0075] (1) First, reconstruct event A from recording 200 (e.g., subprocess 320). In other words, Coordinator 400 sends Event A, and Event A is Entity 1 and Entity 2 stimulates. Therefore, the coordinator 400 puts entity 1 and entity into the queue 410. Insert body 2 (for example, subprocess 330).

[0076] (2) Next, the coordinator 400 executes entity 1 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 1 experiences events B and C It outputs and is reproduced (for example, subprocess 360). In other words, event B and event Event C is sent as a message. Event B stimulates entities 3 and 5. Event C stimulates entity 4. Therefore, coordinator 400 enters queue 41. Insert entities 3, 5, and 4 at the beginning of 0 (for example, subprocess 330). .

[0077] (3) Next, the coordinator 400 executes entity 3 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 3 outputs event E and then It is expressed (for example, subprocess 360). In other words, event E is sent as a message It is believed. Event E stimulates entity 5. However, entity 5 is already in queue 410. It exists. Therefore, insertion into queue 410 will not occur.

[0078] (4) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, insertion into queue 410 will not occur.

[0079] (5) Next, the coordinator 400 executes entity 4 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 4 outputs event F and then It is expressed (for example, subprocess 360). In other words, event F is sent as a message It is believed. Event F stimulates entity 5. Therefore, coordinator 400 waits. Insert entity 5 at the beginning of matrix 410 (for example, subprocess 330).

[0080] (6) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, insertion into queue 410 will not occur.

[0081] (7) Next, the coordinator 400 executes entity 2 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 2 outputs event D and then It is expressed (for example, subprocess 360). In other words, event D is sent as a message. Event D stimulates entities 4 and 5. Therefore, Coordinator 40 0 inserts entities 4 and 5 at the head of queue 410 (for example, subprocess 33 0).

[0082] (8) Next, the coordinator 400 executes entity 4 from the front of the queue 410. (For example, subprocess 350). As a result of this execution, entity 4 outputs event F and then It is expressed (for example, subprocess 360). In other words, event F is sent as a message It is believed. Event F stimulates entity 5. However, entity 5 is already in queue 410. It exists. Therefore, insertion into queue 410 will not occur.

[0083] (9) Next, the coordinator 400 executes entity 5 from the front of the queue 410. (For example, subprocess 350). No events are output during the execution of this entity 5. Therefore, no insertion into queue 410 occurs. Furthermore, after this execution, queue 410 It is empty (for example, "Yes" in subprocess 340), and the event remains in log 200. It is not (for example, it is "No" in subprocess 310). Therefore, coordination Task 400 has completed the reproduction of record 200 (for example, process 300 has finished).

[0084] (2.3. Second Embodiment of the Algorithm) Figure 5 shows the second embodiment, where data is re-entered by placing events into a queue. Algorithm 500 for achieving this is shown. Algorithm 500 is the actual software entity Coordinate the reproduction of lines and events (e.g., sending events to software entities), and This can be done by a coordinator that manages the queue of output events. Please understand this. The coordinator will run the software entity on system 250 and One or more processors 110 of the same or communicating system 100 This can be executed. As mentioned above regarding algorithm 300, the coordination The system can learn the topology of the system being reproduced.

[0085] In subprocess 510, algorithm 500 checks if there is a next event to reproduce. Determine whether or not. If the next event that can be reproduced (i.e., subprocess 510) If the answer is "Yes", algorithm 500 will then process the following event in subprocess 520. Reproduce. Otherwise, if there is no next event to reproduce (i.e., subprocess) If "No" is selected in 510, algorithm 500 may terminate. Subprocess 510 This may be similar to or identical to subprocess 310, and therefore, in this specification It is not explained redundantly. Any explanation of subprocess 310 is equivalent to that of subprocess 510. It should be understood that this can be applied in both directions, and vice versa.

[0086] In subprocess 520, algorithm 500 reproduces the following event: Process 520 may be similar to or identical to subprocess 320, and therefore, Any description of subprocess 320 is not redundant in the specification. It should be understood that this can be applied equally to S520, and vice versa.

[0087] In subprocess 530, algorithm 500 is reproduced in subprocess 520. Execute all software entities (if any) that are triggered by the event. Zero, one, or more software entities reproduced the event in subprocess 520. It is important to understand that events can be triggered by each event. A software entity is executed to process events as input. For example, a software The software entity parses the data within the message representing the input event and processes that data. This can generate one or more output events. Each of these output events is It can be represented as another message sent to one or more other software entities. Yes, it is possible. In subprocess 530, stimulated software entities can be in parallel or serial. It may be executed. The coordinator uses input events to call the software entity. By releasing or otherwise triggering any given system within system 250 It is possible to control the execution of software entities and receive output events as responses. can.

[0088] In subprocess 540, algorithm 500 is implemented in subprocess 530. It waits for all events (if any) output by the executed software entity. Add to a column. This adds an actual event (e.g., a message) to a queue. Please understand that this is not necessary. Rather, when an event is added to or inserted into the queue... When discussed herein as such, this refers to an event identifier or participation in an event. This includes situations where a light is added to or inserted into a queue. The event follows various strategies. They can be added to the queue. For some of these strategies, a second implementation Modifications of the form will be discussed below with reference to Figures 6A to 6C. The important point is, The matrix provides a regenerative ordering of the output events. Depending on the circumstances, the software entity running in subprocess 530 may not be affected by any event. No output was produced, and as a result, no events were inserted into the queue in subprocess 540. It should be understood that this may not be possible.

[0089] In sub - process 550, algorithm 500 determines whether the queue is empty, or conversely, whether there are any events remaining in the queue. If the queue is empty ( i.e., "Yes" in sub - process 550), algorithm 500 returns to sub - process 510 and determines whether there are any events remaining in the record. Otherwise, if at least one event remains in the queue (i.e., "No" in sub - process 550), algorithm 500 removes the next event in the queue and reproduces that next event in sub - process 560 (e.g., by sending a message representing the event to one or more software entities ). Specifically, for example, an event can be transferred to one or more software entities or broadcast to multiple software entities. Next, algorithm 500 returns to sub - process 530 and executes any software entities stimulated by the event sent in sub - process 560.

[0090] In summary, in this second embodiment represented by algorithm 500, events output by software entities are placed in a queue. The order in which events are placed in the queue can be implemented according to various strategies as long as the same order is reproduced in all reproductions. When an event is sent from the queue, all software entities stimulated by the event [[ID= 34]]can be executed in parallel, and the stimulated software ​​​Events output by an entity are placed into a queue according to the selected strategy. In one embodiment, the execution of all software entities is initiated by the next event from a queue. If it is not completed before reproduction (sending) (for example in subprocess 520 or 560) It must be (for example, subprocess 530). When sending an event, depending on the strategy And, it forwards only a single event at a time, or is generated by the execution of a software entity. Either all events to be performed are forwarded at once. The coordinator then triggers a replay of the next event from the records.

[0091] In Algorithm 500, variations of the strategy for adding events to a queue are shown below. These are shown in Figures 6A-6C. However, these strategies are non-exclusive examples, and other strategies are possible. Please understand this.

[0092] (2.3.1. First modified example of the second embodiment) Figure 6A shows the operation of algorithm 500 with a first variation of the queueing strategy. This is shown. In this first modified example, the coordinator 400 processes each newly outputted event. Insert it at the end of queue 410 and send only one event at a time. Therefore, Coordinator 400 reproduces Record 200 as follows:

[0093] (1) First, reconstruct event A from recording 200 (e.g., subprocess 520). In other words, Coordinator 400 sends Event A, and Event A is Entity 1 and Entity This stimulates 2 and 2. As a result, entity 1 and entity 2 are executed (for example, subprocess 530 ), and together output Event B, Event C, and Event D. Therefore, The coordinator 400 assigns events B, C, and D to the queue 410. Insert (for example, subprocess 540).

[0094] (2) Next, starting from the front of queue 410, reproduce event B (for example, subprocess (S560). In other words, Event B is sent as a message. Event B is entity 3 It stimulates entity 5. Therefore, the coordinator 400 is at the end of the queue 410. Then, insert event E (for example, subprocess 540).

[0095] (3) Next, starting from the front of queue 410, reproduce event C (for example, subprocess (S560). In other words, Event C is sent as a message. Event C is entity 4 This stimulates [something]. As a result, entity 4 is executed (for example, subprocess 530), and event F It outputs the following: Therefore, the coordinator 400 places the event at the end of the queue 410. Insert F (for example, subprocess 540).

[0096] (4) Next, starting from the front of queue 410, reproduce event D (for example, subprocess (S560). In other words, Event D is sent as a message. Event D is entity 4 This stimulates entity 5. As a result, entities 4 and 5 are executed (for example, subprocesses). 530), and then output event F. Therefore, Coordinator 400 waits. Insert event F at the end of matrix 410 (for example, subprocess 540).

[0097] (5) Next, starting from the front of queue 410, reproduce event E (for example, subprocess (S560). In other words, Event E is sent as a message. Event E is entity 5 stimulates it. As a result, entity 5 is executed (for example, sub-process 530), but no event is output. Therefore, no insertion into the queue 410 is performed.

[0098] (6) Next, from the head of the queue 410, event F is reproduced (for example, sub-process 560). That is, event F is transmitted as a message. Event F stimulates entity 5 As a result, entity 5 is executed (for example, sub-process 530), but no event is output. Therefore, no insertion into the queue 410 is performed.

[0099] (7) Next, from the head of the queue 410, event F is reproduced (for example, sub-process 560). That is, event F is transmitted as a message. Event F stimulates entity 5 As a result, entity 5 is executed (for example, sub-process 530), but no event is output. Therefore, no insertion into the queue 410 is performed. Furthermore, after this execution, the queue 410 is empty (for example, "Yes" in sub-process 550), and no event remains in record 2 00 (for example, "No" in sub-process 510). Therefore, the coordinator 400 has completed the reproduction of record 200 (for example, process 500 ends).

[0100] (2.3.2. Second Variant of the Second Embodiment) FIG. 6B shows the operation of algorithm 500 according to a second variant of the strategy for putting into a queue. In this second variant, the coordinator 400 inserts each newly output event at the head of the queue 410 and reproduces (for example, transmits) only one event at a time. ​Therefore, Coordinator 400 reproduces Record 200 as follows:

[0101] (1) First, recreate event A from recording 200 (for example, subprocess 520). In other words, Coordinator 400 sends Event A. Event A is sent between entity 1 and entity Stimulates entity 2. As a result, entity 1 and entity 2 are executed (for example, subprocess 53 0) Then, output Event B, Event C, and Event D together. Therefore, Coordinator 400 assigns events B, C, and D to queue 410. Insert (for example, subprocess 540).

[0102] (2) Next, starting from the front of queue 410, reproduce event B (for example, subprocess (S560). In other words, Event B is sent as a message. Event B is entity 3 This stimulates entity 5. Therefore, the coordinator 400 is at the front of the queue 410. Insert event E (for example, subprocess 540).

[0103] (3) Next, starting from the front of queue 410, reproduce event E (for example, subprocess (S560). In other words, Event E is sent as a message. Event E is entity 5 This stimulates the event. As a result, entity 5 is executed (e.g., subprocess 530), but the event The output is not displayed. Therefore, insertion into queue 410 does not occur.

[0104] (4) Next, event C is reproduced from the front of queue 410 (for example, subpro Seth 560). In other words, Event C is sent as a message. Event C is an entity Stimulate 4. As a result, entity 4 is executed (e.g., subprocess 530), and an event occurs. It outputs F. Therefore, the coordinator 400 puts the event at the head of the queue 410. Insert F (for example, subprocess 540).

[0105] (5) Next, starting from the front of queue 410, reproduce event F (for example, subprocess (S560). In other words, Event F is sent as a message. Event F is entity 5 This stimulates the event. As a result, entity 5 is executed (e.g., subprocess 530), but the event The output is not displayed. Therefore, insertion into queue 410 does not occur.

[0106] (6) Next, starting from the front of queue 410, reproduce event D (for example, subprocess (S560). In other words, Event D is sent as a message. Event D is entity 4 This stimulates entity 5. As a result, entities 4 and 5 are executed (for example, subprocesses). 530) Then, output Event F in a batch. In this way, Coordinator 400 waits Insert event F at the beginning of matrix 410 (for example, subprocess 540).

[0107] (7) Next, starting from the front of queue 410, reproduce event F (for example, subprocess (S560). In other words, Event F is sent as a message. Event F is entity 5 This stimulates the event. As a result, entity 5 is executed (e.g., subprocess 530), but the event The output is not displayed. Therefore, insertion into queue 410 does not occur. Furthermore, this actual After the line, queue 410 is empty (e.g., subprocess 550 has "Yes"), and record 2 No events remain in 00 (for example, "No" in subprocess 510). Therefore, Coordinator 400 completed the reproduction of Record 200 (for example, Process 50) (0 ends).

[0108] (2.3.3. Third modified example of the second embodiment) Figure 6C shows the operation of algorithm 500 with a third variation of the queueing strategy. This is shown. In this third modification, the coordinator 400 processes each newly outputted event. Insert into the front of queue 410 and all the output by the given software entity Simultaneously reproduce the vent (e.g., transmit). Therefore, Coordinator 400 will do the following: Recreate record 200 as shown.

[0109] (1) First, reconstruct event A from recording 200 (e.g., subprocess 520). In other words, Coordinator 400 sends Event A, and Event A is Entity 1 and Entity This stimulates both entities. As a result, entities 1 and 2 are executed (for example, subprocess 53). 0). Therefore, Coordinator 400 puts events B+C and event B into queue 410. Insert event D (for example, subprocess 540). Of note are events B and C and Since both were output by a single software entity (i.e., entity 1), the queue This is to add it as a collective event at a single location in column 410.

[0110] (2) Next, starting from the front of queue 410, reproduce event B+C (for example, sub (Roses 560). In other words, Event B and Event C are sent simultaneously as messages. Event B stimulates entities 3 and 5, and Event C stimulates entity 4. As a result, entities 3, 4, and 5 are executed (for example, subprocess 530). Body 3 outputs event E, entity 4 outputs event F, and entity 5 outputs no event. Therefore, Coordinator 400 will place Event E and Event E at the front of the queue 410. Insert a subprocess F (for example, subprocess 540).

[0111] (3) Next, reproduce event E from the front of queue 410 (for example, subprocess 560). In other words, Event E is sent as a message. Event E sends entity 5 Stimulate. As a result, entity 5 is executed (for example, subprocess 530), but event This is not output. Therefore, insertion into queue 410 does not occur.

[0112] (4) Next, starting from the front of queue 410, reproduce event F (for example, subprocess (S560). In other words, Event F is sent as a message. Event F is entity 5 This stimulates [something]. As a result, entity 5 is executed (for example, subprocess 530), but the event The output is not displayed. Therefore, insertion into queue 410 does not occur.

[0113] (5) Next, starting from the front of queue 410, reproduce event D (for example, subprocess (S560). In other words, Event D is sent as a message. Event D is entity 4 This stimulates entity 5. As a result, entity 4 and entity 5 are executed (for example, subprocess (S530). Entity 4 outputs event F, and entity 5 does not output an event. Therefore The coordinator 400 inserts event F at the beginning of the queue 410 (for example, Subprocess 540).

[0114] (6) Next, starting from the front of queue 410, reproduce event F (for example, subprocess (S560). In other words, Event F is sent as a message. Event F is entity 5 This stimulates [something]. As a result, entity 5 is executed (for example, subprocess 530), but the event The output is not displayed. Therefore, insertion into queue 410 does not occur. Furthermore, this actual After the line, queue 410 is empty (e.g., subprocess 550 has "Yes"), and record 2 No events remain in 00 (for example, "No" in subprocess 510). Therefore, Coordinator 400 completed the reproduction of Record 200 (for example, Process 50) (0 ends).

[0115] The above description of the disclosed embodiments indicates that anyone skilled in the art could manufacture or use the present invention. These are provided for the purpose of doing so. Various modifications to these embodiments are available. As will be readily apparent to the experts, the general principles described herein do not represent the spirit or scope of the invention. It is possible to apply this to other embodiments without departing from this specification. Thus, The descriptions and drawings presented represent currently preferred embodiments of the present invention, and therefore, the present invention Therefore, it will be understood that this represents a broadly intended subject matter. Furthermore, the scope of this invention This scope fully encompasses other embodiments that may be obvious to those skilled in the art, and also extends the scope of the present invention. It should be understood that the boundaries are not limited.

[0116] In this specification, "at least one of A, B, or C" and "one of A, B, or C" are used. "One or more," "At least one of A, B, and C," "One or more of A, B, and C," Combinations such as "A, B, C, or any combination thereof" are A, B, and / Or any combination of C, and any multiple of A, B, or C. It may include: Specifically, "at least one of A, B, or C", "A, B, and is one or more of C's, at least one of A, B, and C's, one of A, B, and C's The above, combinations such as "A, B, C, or any combination thereof" are only A, It may be B only, C only, A and B, A and C, B and C, or A and B and C. Any such combination includes one or more of its components A, B, and / or C. Yes, that is fine. For example, combinations of A and B include one A and multiple B, multiple A and one B, Alternatively, it may include multiple A's and multiple B's.

Claims

1. Multiple software entities within a system can be represented as nodes in a graph, and events as edges in the graph, and a method for definitively reconstructing a record of events between the multiple software entities within the system using at least one hardware processor, wherein for each of one or more events in the record, Steps to reproduce the aforementioned event, The steps include placing one of the plurality of software entities stimulated by the aforementioned event into a queue, Until the aforementioned queue is empty, The steps include deleting the software entity at the head of the aforementioned queue and executing it, The steps include: reproducing all events output by the aforementioned executed software entity; A method comprising the step of placing one of the plurality of software entities that are stimulated by the reproduced event output by the executed software entity into the queue.

2. The method according to claim 1, wherein each step of reproducing the event includes sending a message representing the event to one or more of the plurality of software entities.

3. The method according to claim 1, wherein each step of placing a software entity into the queue includes inserting the software entity into the queue regardless of whether the software entity already exists at a position in the queue.

4. The method according to claim 3, wherein inserting the software entity into the queue includes inserting the software entity at the end of the queue.

5. The method according to claim 3, wherein inserting the software entity into the queue includes inserting the software entity at the beginning of the queue.

6. The method according to claim 1, further comprising the step of using the at least one hardware processor to ensure that the event is not reproduced during the execution of any of the plurality of software entities.

7. The method according to claim 1, further comprising using the at least one hardware processor to ensure that no software entity is executed while any of the other software entities are being executed.

8. The method according to claim 1, wherein the system is a subsystem of a vehicle.

9. The method according to claim 1, wherein the system is a subsystem of a robot.

10. Multiple software entities within a system can be represented as nodes in a graph, and events as edges in the graph, and a method for definitively reconstructing a record of events between the multiple software entities within the system using at least one hardware processor, wherein for each of one or more events in the record, Steps to reproduce the aforementioned event, The steps include: executing one of the plurality of software entities that are stimulated by the aforementioned event; The steps include: placing all events output by any of the executed software entities into a queue; Until the aforementioned queue is empty, The steps include deleting and reproducing the event at the head of the aforementioned queue, The steps include: executing one of the plurality of software entities that are stimulated by the reproduced event that has been removed from the front of the queue; A method for definitively reproducing an event record between multiple software entities in a system, comprising the step of adding to the queue all events output by any of the executed software entities stimulated by the reproduced event that was removed from the front of the queue.

11. The method according to claim 10, wherein each step of reproducing the event includes sending a message representing the event to one or more of the plurality of software entities.

12. The method according to claim 10, wherein each step of placing an event into the queue includes inserting the event into the queue regardless of whether the event already exists at a position in the queue.

13. The method of claim 10, wherein the step of executing any of the plurality of software entities that are triggered by the event removed from the front of the queue or by the event that is reproduced includes the step of executing any of the plurality of software entities in parallel.

14. The method according to claim 10, wherein the system is a subsystem of a vehicle.

15. The method according to claim 10, wherein the system is a subsystem of a robot.

16. A non-temporary computer-readable medium having instructions stored therein, wherein, when executed by a processor, the instructions can represent a plurality of software entities in a system as nodes of a graph and events as edges of the graph, and a method by which the processor definitively reproduces a record of events between the plurality of software entities in the system, wherein for each of one or more events in the record, Steps to reproduce the aforementioned event, The steps include: executing one of the plurality of software entities that are stimulated by the aforementioned event; The steps include: placing all events output by any of the executed software entities into a queue; Until the aforementioned queue is empty, The steps include deleting and reproducing the event at the head of the aforementioned queue, The steps include: executing one of the plurality of software entities that are stimulated by the reproduced event that has been removed from the front of the queue; A non-temporary computer-readable medium that causes a method to definitively reproduce a record of events between multiple software entities in a system, by adding to the queue all events output by any of the executed software entities stimulated by the reproduced event that was removed from the front of the queue.

17. The non-temporary computer-readable medium according to claim 16, wherein each step of reproducing an event includes the step of sending a message representing the event to one or more of the plurality of software entities.

18. The non-temporary computer-readable medium according to claim 16, wherein each step of placing an event into the queue includes inserting the event into the queue regardless of whether the event already exists at a position in the queue.

19. The non-temporary computer-readable medium according to claim 16, wherein the step of executing any of the plurality of software entities that are triggered by the event removed from the front of the queue or by the event that is reproduced includes the step of executing any of the plurality of software entities in parallel.

20. The non-temporary computer-readable medium according to claim 16, wherein the system is a subsystem of a vehicle or robot.

Images