Cooperative failure analysis method based on time patterns in platooning system of systems

Abstract

To provide a method for timed pattern-based collaboration failure analysis in a platooning system-of-systems (SoS).SOLUTION: A method for timed pattern-based collaboration failure analysis in a system-of-systems (SoS) implemented by a computer device, according to an embodiment, comprises extracting an interaction collaboration failure pattern through a collaboration failure analysis using an interaction model generated from an interaction log executed in the system-of-systems, and localizing a fault of an interaction bug from the extracted interaction collaboration failure pattern.SELECTED DRAWING: Figure 5

Description

[Technical field]

[0001] The following description relates to techniques for analyzing data failures. [Background technology]

[0002] A large-scale complex system, a System-of-Systems (SoS), is a system in which heterogeneous systems cooperate with each other to achieve goals that cannot be achieved by a single system. Typical examples of a System-of-Systems include smart homes, smart plants, and intelligent transportation systems. In such large-scale systems, multiple constituent systems closely interact with each other to perform specific operations and achieve goals. For example, a Platooning System, a type of intelligent transportation system, exchanges an average of 17 messages to perform operations such as leaving, merging, and splitting, which maintains the platoon and enables vehicles to join and leave as necessary.

[0003] Interaction-based systems of systems have the tendency to cause system coordination failures due to interaction bugs that were not often found in the past. However, the reality is that no technology suitable for efficiently extracting and providing the information required to resolve such interaction bugs exists to date. Furthermore, inferring interaction bugs from system failures requires high-level background knowledge about the system itself. In particular, existing research has various limitations in analyzing interaction coordination failures in system-of-systems, including (1) a lack of technical capabilities for interaction log analysis processing, (2) the absence of a clustering technique that takes cascading failures into account, and (3) the absence of a technique to link extracted failure patterns to errors in the code. Summary of the Invention [Problem to be solved by the invention]

[0004] We present TIME-LCS (TImed Message pattern Extraction-Longest Common Subsequence) pattern mining to extract accurate interaction coordination failure patterns, taking into account multi-dimensional and temporal features.

[0005] Time overlap clustering is used to classify all interaction coordination failure patterns that occur during the execution of a system of systems.

[0006] By calculating the suspiciousness degree of the cooperative protocol code according to the sequentiality of the execution of the protocol code, the error location is estimated from the interaction cooperative failure pattern. [Means for solving the problem]

[0007] A method for time pattern based coordination failure analysis in a system of systems (SOS) executed in a computer device may include a step of extracting an interaction coordination failure pattern through coordination failure analysis in an interaction model generated from an interaction log executed in the SOS, and a step of estimating an error location of an interaction bug from the extracted interaction coordination failure pattern.

[0008] The extracting step may include a step of checking whether the interaction log satisfies a target attribute using an interaction log executed in the system of systems and a pass tag and a fault tag of the interaction log.

[0009] The extracting may include generating a message sequence based on a message in an interaction log including the fault tag.

[0010] The system of systems may include a platooning system of systems, and the extracting step may include a step of utilizing an interaction model generated in the platooning system of systems to represent an interaction log between constituent systems (CS) as a sequence of communication messages between vehicles.

[0011] The extracting step may include extracting the system-of-system interaction coordination failure pattern by extracting a common subsequence (Longest Common Subsequence) through a TIME-LCS (TIMEd Message pattern Extraction-Longest Common Subsequence) based coordination failure analysis taking into account multi-dimensional and temporal characteristics of the interaction log.

[0012] The extracting step may include classifying a plurality of common patterns for the extracted interaction coordination fault patterns by grouping interaction logs including fault tags by time overlap clustering.

[0013] The extracting step may include calculating a similarity between message sequences based on a TIME-LCS (TIMed Message pattern Extraction-Longest Common Subsequence).

[0014] The extracting step may include, in the case of a cluster with a single message sequence, calculating a similarity based on the length of a joint subsequence extracted by a TIME-LCS function of each message sequence using the message sequences of the existing cluster and the single message sequence.

[0015] The extracting may include, in the case of a cluster having two or more message sequences, calculating a co-subsequence-based sequence similarity using a co-subsequence pattern of an existing cluster and a single message sequence.

[0016] The extracting step may include determining whether to add a message sequence to an existing cluster or create a new cluster using a threshold for calculating the similarity and a metric for calculating the similarity.

[0017] The extracting step may include creating a new cluster with the message sequence if no cluster similar enough to add the message sequence exists.

[0018] The extracting step may include adding the message sequence to an existing cluster if the message sequence is similar enough to be added to the existing cluster, and updating common subsequence patterns of the existing clusters using the message sequence.

[0019] The extracting step may include repeatedly performing a time overlap clustering process until no more of the message sequences exist, returning an interaction coordination failure pattern and a clustered log set.

[0020] The estimating step may include estimating a location of a suspicious code relative to a system of systems coordination protocol code from the extracted interaction coordination failure pattern.

[0021] The estimating step may include estimating the location of the suspicious code using a code coverage calculation method by performing configuration system level operations.

[0022] The estimating step may include measuring code coverage by executing constituent system-level activities to build a code coverage set that records the lines of code executed for each activity.

[0023] The step of estimating may include a step of using the constructed code range set to rank cooperation protocols according to the degree of suspiciousness of a cause of a fault.

[0024] The estimating step may include prioritizing code statements that are repeatedly executed in configuration system-level operations associated with interaction coordination failure patterns using SeqOverlap, which calculates the degree of suspiciousness of a failure cause based on the number of sequential overlaps.

[0025] A computer program recorded on a computer-readable recording medium for executing a method for analyzing coordination failures based on a time pattern in a system of systems (SOS) executed by a computer device, the method for analyzing coordination failures based on a time pattern in a system of systems may include a step of extracting an interaction coordination failure pattern by coordination failure analysis in an interaction model generated from an interaction log executed in the system of systems, and a step of estimating an error location of an interaction bug from the extracted interaction coordination failure pattern.

[0026] A computer device comprising at least one processor configured to execute computer-readable instructions contained in a memory, the at least one processor extracting an interaction coordination failure pattern by coordination failure analysis in an interaction model generated from an interaction log executed in a system of systems, and estimating an error location of an interaction bug from the extracted interaction coordination failure pattern. Effect of the Invention

[0027] It reduces the human and time resources required to resolve unpredictable interaction bugs within large complex systems.

[0028] The effects of generating the most accurate interaction coordination fault pattern from the platoon driving interaction log, deriving a significantly high overlap clustering accuracy when considering chain failures, and enabling the interaction coordination fault error location estimation algorithm to efficiently reduce debugging costs compared to spectrum-based fault location estimation methods can be achieved. [Brief description of the drawings]

[0029] [Figure 1] FIG. 1 illustrates an example of a platooning operation failure, such as a stalemate, identified through a simulation using a simulator, in one embodiment. [Diagram 2] FIG. 2 is a diagram showing a communication message sequence between vehicles in a platooning system of systems in one embodiment. [Diagram 3] FIG. 2 is a diagram illustrating a configuration of a computer device according to an embodiment. [Figure 4] 1 is a diagram illustrating a method for analyzing coordination failures based on a time pattern in a system of systems according to an embodiment. [Diagram 5] FIG. 13 is a diagram illustrating a coordinated failure analysis operation in one embodiment. [Figure 6] FIG. 1 illustrates LCS patterns extracted for the same message sequence in different time windows in one embodiment. [Figure 7] 11 is an exemplary diagram illustrating an operation of estimating a defect position on a pattern board according to an embodiment; DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0030] Hereinafter, the embodiments will be described in detail with reference to the accompanying drawings.

[0031] FIG. 1 is a diagram illustrating a platooning operation failure, such as a stalemate, found through a simulation using a simulator, in one embodiment.

[0032] The scenario shows two platoons: Platoon 1 with size 3 and Platoon 2 with size 4, where V1 and V5 are shown as leaders of each platoon. The failure occurs due to a simultaneous merge request from V5 and a leave request from V7. In this case, since V5 is in the middle of a merge operation, it continues to ignore the leave operation from V7. Furthermore, the communication between V5 and V7 causes the merge wait time to be exceeded, and V5 also fails to perform the merge operation successfully. Such failures due to complex interactions are a major challenge in achieving the goal of platooning and lead to serious collisions.

[0033] FIG. 2 is a diagram showing a communication message sequence between vehicles in a platooning system of systems in one embodiment.

[0034] First, we describe the LCS algorithm and interaction model for interaction logs executed in a system of systems. The LCS algorithm finds the longest common subsequence between two strings. JPEG0007613772000001.jpg69, JPEG0007613772000002.jpg517∈, JPEG0007613772000003.jpg615, JPEG0007613772000004.jpg657 and Let JPEG0007613772000005.jpg652 be strings with lengths m and n, respectively. The function LCS:String×String->String maps two input strings to the longest common subsequence associated with the two strings. The LCS function may be defined as follows:

[0035]

number

[0036] function JPEG0007613772000007.jpg626:String×String->String selects the longer of the two input strings. If the length of the two strings is zero, the LCS function outputs an empty string. JPEG0007613772000008.jpg99 means the concatenation of the operands. If the two input strings contain characters in common, the function converts the characters to LCS(s m-1 , s n-1 ) recursively.

[0037] In order to comprehensively analyze the coordination failure of a system of systems, the analysis may be centered on the interaction logs of the constituent systems (CS). The interaction model of a system of systems shows the interaction logs as message sequences between the constituent systems. The definitions of messages and message sequences are as follows:

[0038] JPEG0007613772000009.jpg26130

[0039] where m n is a finite sequence of messages of length n. Each msg in the sequence iis an ordered tuple consisting of continuity, synchronization, sender, receiver, content, and time. For example, Figure 2 shows a communication message sequence between vehicles in a platooning system of systems. In the scenario in Figure 2, V1 wants to leave Platoon1 and sends a message to V2. The message msg1 sent to V2 is<TC、Sync、V1、V2、LEAVE_REQ、00:00:01> which means a temporary (TC) and synchronization (Sync) communication from V1 to V2 using the LEAVE_REQ command at 00:00:01. The message sequence from LEAVE_REQ to SPLITE_START may be made with m4=msg1, msg2, msg3, msg4. In this way, we consider the time window of the interaction log in the pattern mining. Therefore, m n teeth JPEG0007613772000010.jpg89, where t denotes the start time of the time window.

[0040] FIG. 3 is a diagram illustrating a configuration of a computer device according to an embodiment.

[0041] Such a computer device 300 may include a memory 310, a processor 320, a communication interface 330, and an input / output interface 340. The memory 310 is a computer-readable recording medium and may include a random access memory (RAM), a read only memory (ROM), and a permanent mass storage device such as a disk drive. Here, a permanent mass storage device such as a ROM or a disk drive may be included in the computer device 300 as a separate permanent storage device separate from the memory 310. The memory 310 may also store an operating system and at least one program code. Such software components may be loaded into the memory 310 from a computer-readable recording medium separate from the memory 310. Such separate computer-readable recording medium may include a computer-readable recording medium such as a floppy drive, a disk, a tape, a DVD / CD-ROM drive, a memory card, etc. In another embodiment, the software components may be loaded into the memory 310 through a communication interface 330 that is not a computer-readable recording medium. For example, the software components may be loaded into the memory 310 of the computing device 300 based on a computer program installed by a file received over the network 170 .

[0042] The processor 320 may be configured to process instructions of a computer program by performing basic arithmetic, logic, and input / output operations. The instructions may be provided to the processor 320 by the memory 310 or the communication interface 330. For example, the processor 320 may be configured to execute instructions received according to program code stored in a storage device such as the memory 310.

[0043] The communication interface 330 may provide a function for the computer device 300 to communicate with other devices (for example, the above-mentioned recording device) via the network 370. For example, requests, instructions, data, files, etc. generated by the processor 320 of the computer device 300 according to program codes recorded in a recording device such as the memory 310 may be transmitted to other devices via the network 370 under the control of the communication interface 330. Conversely, signals, instructions, data, files, etc. from other devices may be received by the computer device 300 via the communication interface 330 of the computer device 300 via the network 370. The signals, instructions, data, etc. received via the communication interface 330 may be transmitted to the processor 320 or the memory 310, and the files, etc. may be recorded on a recording medium (the above-mentioned permanent recording device) that the computer device 300 may further include.

[0044] The input / output interface 340 may be a means for interfacing with the input / output device 350. For example, the input device may include a device such as a microphone, a keyboard, or a mouse, and the output device may include a device such as a display and a speaker. As another example, the input / output interface 340 may be a means for interfacing with a device in which functions for input and output are integrated into one, such as a touch screen. The input / output device 350 may be configured as one device together with the computer device 300.

[0045] Also, in other embodiments, the computing device 300 may include fewer or more components than those of Figure 3. However, most of the prior art components need not be explicitly illustrated. For example, the computing device 300 may be implemented to include at least some of the input / output devices 350 described above, and may further include other components such as a transceiver, a database, etc.

[0046] A specific embodiment of a method and apparatus for analyzing coordination failures based on a time pattern in a system of systems will be described below.

[0047] The processor 320 of the computing device 300 may be implemented as a component for executing a method for time pattern based collaborative fault analysis in a system of systems. Depending on the embodiment, the components of the processor 320 may be selectively included or excluded from the processor 320. Also, depending on the embodiment, the components of the processor 320 may be separated or combined to represent the functions of the processor 320.

[0048] Such processor 320 and components of processor 320 may control computer device 300 to perform steps included in a method for time pattern based collaborative fault analysis in a system of systems, described below. For example, processor 320 and components of processor 320 may be implemented to execute instructions from operating system code and at least one program code contained in memory 310.

[0049] Here, the components of the processor 320 may represent different functions that are performed by the processor 320 according to instructions provided by program code stored in the computing device 300 .

[0050] The processor 320 may read the necessary instructions from the memory 310, which is loaded with instructions related to the control of the computing device 300. In this case, the read instructions may include instructions for controlling the processor 320 to perform the steps described below.

[0051] Hereinafter, the steps including the method for analyzing coordination failures based on time patterns in a system of systems may be performed in an order different from that shown in the figures, some steps may be omitted, or additional processes may be included.

[0052] FIG. 4 is a diagram illustrating a method for analyzing a coordination failure based on a time pattern in a system of systems according to an embodiment.

[0053] In step 410, the processor 320 may generate an interaction model using an interaction log executed in the system of systems. The processor 320 may check whether the interaction log satisfies a target attribute using the interaction log executed in the system of systems and a passing tag and a fault tag in the interaction log. The processor 320 may generate a message-based message sequence from the interaction log including the fault tag. The processor 320 may represent the interaction log between constituent systems (CS) as a communication message sequence between vehicles using the interaction model generated in the platooning system of systems.

[0054] In step 420, the processor 320 may extract an interaction coordination failure pattern through coordination failure analysis in the generated interaction model. The processor 320 may extract an interaction coordination failure pattern of a system of systems by a method of extracting a common subsequence (Longest Common Subsequence: LCS) through coordination failure analysis based on TIME-LCS (TImed Message pattern Extraction-Longest Common Subsequence) considering multi-dimensional and temporal characteristics of an interaction log. The processor 320 may classify a plurality of common patterns for the extracted interaction coordination failure pattern by grouping interaction logs including a failure tag through time overlap clustering. The processor 320 may calculate a similarity of message sequences based on the TIME-LCS. In the case of a cluster with a single message sequence, the processor 320 may calculate a similarity according to the length of a common subsequence extracted from a TIME-LCS function between each message sequence using the message sequence of the existing cluster and the single message sequence. For clusters with two or more message sequences, the processor 320 may calculate a co-subsequence-based sequence similarity using the co-subsequence patterns of existing clusters and a single message sequence. The processor 320 may use a threshold for calculating similarity and a metric for calculating similarity to determine whether to add the message sequence to an existing cluster or to generate a new cluster. The processor 320 may generate a new cluster with the message sequence if there is no cluster similar enough to add the message sequence to. The processor 320 may add the message sequence to an existing cluster and update the common subsequence patterns of the existing clusters using the message sequence if the message sequence is similar enough to be added to the existing cluster. The processor 320 may repeatedly perform the time overlap clustering process until no message sequences exist to return interaction coordination failure patterns and clustered log sets.

[0055] In step 430, the processor 320 may estimate an error location of an interaction bug from the extracted interaction coordination failure pattern. The processor 320 may estimate a location of suspicious code relative to a system-of-systems coordination protocol code from the extracted interaction coordination failure pattern. The processor 320 may estimate the location of suspicious code using a code coverage calculation method for configuration system level operations. The processor 320 may build a code coverage set that records the lines of code executed for each operation by measuring the code coverage by executing the configuration system level operations. The processor 320 may use the built code coverage set to give a ranking to the coordination protocol according to the suspiciousness of the fault cause. The processor 320 may prioritize code statements that are repeatedly executed in the configuration system level operations associated with the interaction coordination failure pattern using SeqOverlap, which calculates the suspiciousness of the fault cause based on the number of sequential overlaps.

[0056] FIG. 5 is a diagram for explaining a coordinated failure analysis operation in one embodiment.

[0057] The computer device analyzes the TIME-LCS pattern-based coordination failures by an approach consisting of three techniques including TIME-LCS pattern mining (530), TIME overlap clustering (520), and pattern-based fault location estimation (540). The computer device defines a TIME-LCS algorithm for covering the multidimensional structure of the interaction log and extracting the interaction coordination failure patterns of the system of systems. The TIME-LCS algorithm also considers the time characteristics of the interactions to improve the accuracy of the pattern mining. The computer device may classify and extract multiple interaction coordination failure patterns by time overlap clustering. In the time overlap clustering, the interaction coordination failure patterns may be used as the center point of each group. Therefore, the metrics required for clustering are defined based on the TIME-LCS algorithm. The computer device estimates the location of the root cause of the coordination failure based on the interaction coordination failure patterns.

[0058] The computing device may use two main inputs. The computing device may use the system of systems interaction logs and the pass / fail tag of each log to check whether the interaction log meets a specific target attribute. As described in FIG. 2, the computing device is based on the system of systems interaction model format. Therefore, in the pre-processing stage, the computing device can return an interaction message sequence (M) by abstracting all message-based interactions in each log where a failure occurs. For example, in the upper example of FIG. 5, the first message in the interaction log is time (0.00), continuity (TC), synchronization (Sync), sender (Leader), receiver (Follower), and content (SPLIT REQ). Here, we do not use concrete instance IDs for senders and receivers such as V1 and V5, but abstract IDs for the roles of the constituent systems (i.e., Leader or Follower) of the system of systems to extract patterns that occur in other vehicles and time periods.

[0059] The computer device may use the interaction message sequence (M) as input to extract the interaction coordination failure pattern by TIME-LCS pattern mining. The TIME-LCS pattern mining algorithm focuses on dealing with the multi-dimensional and temporal features of the interaction log so that no information loss occurs in the pattern mining.

[0060] First, to handle multidimensionality, the string-based LCS function in Equation 1 is used to It is extended to an LCMS (longest common message subsequence) function based on the definition of JPEG0007613772000011.jpg68.

[0061] Given two input message sequences: JPEG0007613772000012.jpg57 and LCMS mapping JPEG0007613772000013.jpg56 to the longest common message sequence: The JPEG0007613772000014.jpg629 function is defined.

[0062]

number

[0063] In the function maxLenM, JPEG0007613772000016.jpg629 selects the longest message sequence from two inputs. In Equation 1, the comparison of two characters forming a string is obvious. However, a special function is needed to check the identity of two input message sequences. Therefore, a time function MCT and message comparison can be defined that can check the identity of two input message sequences. JPEG0007613772000017.jpg68 and JPEG0007613772000018.jpg67, each showing the previously matched message id JPEG0007613772000019.jpg510, JPEG0007613772000020.jpg48∈ Assume JPEG0007613772000021.jpg68. Function MCT: JPEG0007613772000022.jpg636 may have two input message sequences mapped to Boolean values ​​of message identity as follows:

[0064]

number

[0065] The MCT function includes not only multiple dimensions but also the temporal characteristics of the interaction: it compares the delivery of two input message sequences and rules out situations where certain subsequences occur at significantly different time intervals. JPEG0007613772000024.jpg815 contains a 1 second interval with the previously matched message, Assume JPEG0007613772000025.jpg815 contains an interval of 20 seconds. JPEG0007613772000026.jpg815 and Even if all other values ​​of JPEG0007613772000027.jpg815 are the same, if two input message sequences with significantly different transmission intervals are determined to be identical, this may adversely affect the accuracy of the extracted pattern. Therefore, the process of checking the identity of the message is divided into two cases. If there is no matching message during the extraction of the long common subsequence (LCS) pattern, the computer device checks only the identity of the message content, such as the sender, content, and recipient. If not, the computer device additionally checks whether the difference in the transmission intervals of the input message sequences is within a delay threshold.

[0066] The LCMS function proposed by Equation 2 and Equation 3 extracts LCS patterns of interaction messages between any two input message sequences. However, it cannot be said with any certainty that the proposed LCMS function extracts the most “important” message sequence that contains exactly the information required to identify the root cause of the failure. The term “critical” denotes the quality of information that a particular interaction coordination failure pattern possesses in relation to the coordination failure. Since the LCS-based algorithm starts from the “first match” instance, the LCS pattern may contain completely meaningless parts before the critical point.

[0067] FIG. 6 illustrates LCS patterns extracted from the same message sequence in different time windows in one embodiment.

[0068] Figure 6 shows two example LCS patterns extracted from the same message sequence in different time windows. For example, pattern 1 starts at 53.03 seconds and consists of repeated MERGE_REQ messages and multiple other messages. Pattern 2 starts at 85.00 seconds and includes various messages such as LEAVE_REQ, SPLIT_REQ, MERGE_REQ, etc. between V1, V2, V3, and V5. Pattern 2 provides a more meaningful understanding of the failure where V5 repeatedly requests V3 to merge while V3 is still working on leaving between V2 and V1.

[0069] The computer device defines an algorithm for extracting LCS patterns according to multiple time windows of the input message sequence and selecting the most "critical" LCS from among the LCSs in order to extract the failure pattern of the interaction coordination. JPEG0007613772000028.jpg710|t is the start time of the time window}, M is the set of message sequences, n, k∈ Let JPEG0007613772000029.jpg66 be the length of the message sequence. The sub-message sequences starting at t1 and t2 may be defined as follows:

[0070] JPEG0007613772000030.jpg25113

[0071] To appropriately select the most "critical" LCS from among the selected LCSs, the parameters required to evaluate the quality of the LCS may be defined as the number of content types and the length of the content types in the LCS. If an LCS contains more content types and has a shorter length than other LCSs, it is assumed that this LCS is more "critical" than other LCSs and contains more sequences of information interaction collaboration failure patterns with fewer duplicate messages. Such a definition is based on prioritization among the context and symptoms of the failure. The context indicates the conditions and execution flow in which the error occurs. The symptoms indicate the consequences of the failure and are frequently used as indicators of failure in failure detection techniques. However, the computer device focuses on the analysis of collaborative failures, especially the identification of root causes. During such an analysis process, the failure occurrence context provides more meaningful knowledge that is useful for understanding the root cause. Therefore, the computer device prioritizes LCSs with diverse types of interaction content that provide more context information.

[0072] k, n ∈ Let JPEG0007613772000031.jpg54. For T-LCS and TIME-LCS, the above-mentioned method is defined as follows.

[0073]

number

[0074]

number

[0075] Here is the function NumContentTypes: JPEG0007613772000034.jpg518 maps an input LCS to the number of distinct content types contained in messages that belong to the given LCS. When the algorithm computes T-LCS, it computes the number of distinct content types contained in messages that belong to the given LCS by using discrete time windows in T starting at t1 and t2. JPEG0007613772000035.jpg78 and An LCS set is generated having the sequence of each sub-message of JPEG0007613772000036.jpg68. As described above, TIME-LCS first selects an LCS from T-LCS as many times as the number of content types using Equation 5. If the number of content types is the same, the length of the LCS is used as the tie-handling rule.

[0076] The computer device utilizes time overlap clustering to effectively group similar fault logs based on the TIME-LCS algorithm and extract common patterns of interaction coordination faults. i We assume that overlap clustering is necessary to extract diverse patterns from m i If it is considered that m has multiple failure patterns at the same time, i Add to multiple clusters.

[0077] The computer device defines two similarity calculation metrics (i.e., TIMELen and TIMESim) based on the TIME-LCS function. The reason for presenting these two metrics is that LCS-based algorithms are essentially pairwise algorithms. Thus, the computer device: (a) calculates similarity for a single element (i.e., m i ) and (b) clusters having two or more elements, and uses a different similarity metric for each of the separated cases. i ), there are not enough elements that can generate an LCS pattern for the cluster, so we can use the existing cluster j Given a message sequence of m i For example, the first message sequence, m0, always forms a new cluster, cluster0. The second message sequence, m1, is compared with m0 in cluster0. Thus, a single element (i.e., m i), the similarity of two message sequences is defined as the length of the LCS between the message sequences.

[0078]

number

[0079]

number

[0080] In formula 6, JPEG0007613772000039.jpg622 is a cluster j denote a single message sequence located at m i denotes the message sequence given as input. The TIMELen similarity value is the length of the LCS extracted from the TIME-LCS function. Otherwise, if there are two or more elements in the cluster, TIMEsim in Equation 7 is applied. For clusters with two or more elements, the subject of TIMESim is the LCS pattern of the existing cluster. Given JPEG0007613772000040.jpg842 and a message sequence m i The computer system utilizes the TIMESim metric to i and Calculate the LCS-based sequence similarity between JPEG0007613772000041.jpg842.

[0081] The computer device uses the two metrics along with the threshold, the len threshold, and the similarity threshold to determine m i Decide whether to add m to an existing cluster or create a new cluster. For example, if the similarity threshold is 0.8 and m 10 and If the TIMESim value for JPEG0007613772000042.jpg719 is 0.75, m 10 is not assigned to cluster3. This means that mi The computer device can extract multiple patterns simultaneously from m i cluster j If they are similar enough to be added to m i cluster j and add it to the existing cluster's LCS pattern. m for JPEG0007613772000043.jpg738 i The computer device is updated using m i If there are not enough similar clusters to add, m i The clustering process creates a new cluster with m i It is repeated until no more exists, and finally returns a log set clustered with the interaction coordination failure patterns.

[0082] FIG. 7 is an example for explaining an operation of estimating a fault location on a pattern board in one embodiment.

[0083] A computer device proposes a suspicious code localization technique for a system-of-systems coordination protocol code that can reduce the substantial cost required to localize the root cause of a coordination failure based on a pattern generated based on an interaction coordination failure pattern. The pattern includes a communication message sequence including a CS level operation as a content. The computer device infers suspicious code using the localization technique using a code coverage calculation method for a CS level operation such as SPLIT_REQ or MERGE_REQ. The computer device builds a code coverage set that records the code lines actually executed for each operation by executing all CS level operations and measuring the code coverage. For example, lines 1381-1431 are executed in a single execution of SPLIT_REQ.

[0084] The computer device uses the code range set of each CS level task to prioritize collaboration protocol codes according to the suspiciousness of the fault cause. There have been many studies on spectrum-based fault localization (SBFL) for calculating the suspiciousness of code lines from the scope of code execution. However, the SBFL technique does not consider the sequential execution order, but only the task scope. Therefore, in the embodiment, SeqOverlap, which is a suspiciousness ranking method, is applied based on the number of sequential overlaps of code. The SeqOverlap method aims to prioritize the code statements that are most repeatedly executed in the CS level task sequence of the interaction collaboration fault pattern. For example, the code related to the execution of the first message SPLIT_REQ in the upper part of FIG. 7 includes lines 1381-1393. The next message is SPLIT_ACCEPT, and the related code includes lines 1381-1393. Therefore, lines 1381-1393 have two sequential overlaps. The number of sequential overlaps is calculated in this manner, and the code snippets displayed in the lower part of FIG. 7 are arranged. In this example, lines 853-859 are given first ranking because the code snippet is executed frequently by MERGE_REQ and ACK in the platoon simulation.

[0085] According to one embodiment, an experiment was carried out to apply the approach proposed in the examples (a method for analyzing coordination failures based on time patterns in a system of systems) to the PLTBench platooning system of systems dataset. The technique is compared to existing techniques used for system failure analysis and pattern mining using approximately 8,000 simulation logs of platooning systems to evaluate the performance of the method proposed in the examples. The results obtained from the experiment confirmed that the method proposed in the examples generates the most accurate interaction coordination failure patterns from platooning interaction logs among existing pattern mining techniques, shows significantly higher accuracy of overlap clustering when considering cascading failures, and achieves higher efficiency (average 15% higher accuracy) in reducing debugging costs compared to spectrum-based fault localization (SBFL) methods for error localization of interaction coordination failures.

[0086] In this way, a system of systems (large-scale complex systems) is a system that makes it possible to achieve goals that could not be achieved by a single system, and can be used in a variety of fields. Representative examples include smart homes, smart cities, smart plants, intelligent transportation systems, and disaster response systems. The technology proposed in the embodiment targets general systems of systems, and can be said to have a wide range of application fields in that the necessary and main input value in the system is the system execution record. In recent years, it has been fused with cyber-physical systems and is mainly used under the name Cyber-Physical System of Systems (CPSoS), and is expanding to a wider range of fields.

[0087] Creating such a system requires a lot of effort, but solving errors in the system requires huge costs. The method proposed in the embodiment is expected to be of great help in reducing the human / time resources required to solve bugs in interactions that could not be predicted in large-scale complex systems.

[0088] The above-mentioned devices may be realized by hardware components, software components, and / or a combination of hardware and software components. For example, the devices and components described in the embodiments may be realized using one or more general-purpose or special-purpose computers, such as, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a programmable logic unit (PLU), a microprocessor, or various devices capable of executing and responding to instructions. The processing device may execute an operating system (OS) and one or more software applications that run on the OS. The processing device may also respond to the execution of the software to access, record, manipulate, process, and generate data. For convenience of understanding, a single processing device may be described as being used, but one skilled in the art will understand that the processing device may include multiple processing elements and / or multiple types of processing elements. For example, the processing device may include multiple processors or one processor and one controller. Other processing configurations, such as parallel processors, are also possible.

[0089] The software may include computer programs, codes, instructions, or a combination of one or more of these, and may configure a processing device to operate as desired or instruct the processing device, either independently or collectively. The software and / or data may be embodied in any type of machine, component, physical device, virtual device, computer storage medium, or device to be interpreted based on the processing device or to provide instructions or data to the processing device. The software may be distributed and stored or executed in a distributed manner on computer systems connected by a network. The software and data may be stored on one or more computer-readable storage media.

[0090] The method according to the embodiment may be implemented in the form of program instructions executable by various computer means and recorded on a computer readable medium. The computer readable medium may include, alone or in combination, program instructions, data files, data structures, and the like. The program instructions recorded on the medium may be specially designed for the embodiment or may be available to those skilled in the art of computer software. Examples of computer readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and hardware devices specially configured to record and execute program instructions, such as ROMs, RAMs, flash memories, and the like. Examples of program instructions include high-level language codes executed by a computer using an interpreter, etc., as well as machine language codes such as those generated by a compiler.

[0091] Although the embodiments have been described based on the limited embodiments and drawings as above, those skilled in the art will be able to make various modifications and variations from the above description. For example, the described techniques may be performed in an order different from that described, and / or the components of the described systems, structures, devices, circuits, etc. may be combined or combined in a manner different from that described, or may be counterbalanced or replaced by other components or equivalents, and still achieve suitable results.

[0092] Therefore, different embodiments are within the scope of the appended claims provided that they are equivalent to the claims. [Explanation of symbols]

[0093] 300: Computer equipment 310: Memory 320: Processor 330: Communication interface 340: Input / Output Interface 350: Input / Output Device 370: Network

Claims

1. A method for analyzing a coordination failure based on a time pattern in a system of systems (SOS) executed in a computer device, comprising: Extracting an interaction coordination failure pattern by coordination failure analysis in an interaction model generated from an interaction log executed in the system of systems; estimating an error location of an interaction bug from the extracted interaction coordination failure pattern; A method for analyzing coordination failures based on a time pattern, comprising:

2. The extracting step comprises: determining whether the interaction log satisfies a target attribute by using an interaction log executed in the system of systems and a pass tag and a fault tag of the interaction log; The method for analyzing coordination disorders based on a time pattern according to claim 1 , comprising:

3. The extracting step comprises: generating a message-based message sequence from the interaction log including the fault tag; The method for analyzing coordination disorders based on a time pattern according to claim 2, comprising:

4. The system of systems includes a platooning system of systems, The extracting step comprises: expressing an interaction log between constituent systems (CS) as a communication message sequence between vehicles using an interaction model generated in the platooning system of systems; The method for analyzing coordination disorders based on a time pattern according to claim 1 , comprising:

5. The extracting step comprises: extracting a common subsequence (Longest Common Subsequence) through a TIME-LCS (TIME Message Pattern Extraction-Longest Common Subsequence)-based coordination failure analysis that considers multi-dimensional and temporal characteristics of the interaction log, thereby extracting an interaction coordination failure pattern of the system of systems; The method for analyzing coordination disorders based on a time pattern according to claim 1 , comprising:

6. The extracting step comprises: classifying a plurality of common patterns for the extracted interaction coordination failure patterns by grouping the interaction logs including the failure tags by time overlap clustering; The method for analyzing coordination disorders based on a time pattern according to claim 5, comprising:

7. The extracting step comprises: Calculating the similarity of message sequences based on TIME-LCS (Timed Message Pattern Extraction-Longest Common Subsequence) The method for analyzing coordination disorders based on a time pattern according to claim 6, comprising:

8. The extracting step comprises: In the case of a cluster having a single message sequence, a similarity is calculated based on the length of a joint subsequence extracted from a TIME-LCS function between each message sequence using the message sequences of the existing cluster and the single message sequence. The method for analyzing coordination disorders based on a time pattern according to claim 7, comprising:

9. The extracting step comprises: calculating co-subsequence-based sequence similarity using co-subsequence patterns of existing clusters and a single message sequence in case of clusters having two or more message sequences; The method for analyzing coordination disorders based on a time pattern according to claim 7, comprising:

10. The extracting step comprises: using said threshold for calculating similarity and said metric for calculating similarity to determine whether to add a message sequence to an existing cluster or to create a new cluster. The method for analyzing coordination disorders based on a time pattern according to claim 7, comprising:

11. The extracting step comprises: generating a new cluster having the message sequence if there is no cluster similar enough to add the message sequence to; The method for analyzing coordination disorders based on a time pattern according to claim 10, comprising:

12. The extracting step comprises: adding the message sequence to an existing cluster if the message sequence is similar enough to be added to the existing cluster, and updating common subsequence patterns of the existing cluster with the message sequence. The method for analyzing coordination disorders based on a time pattern according to claim 10, comprising:

13. The extracting step comprises: and repeating the time-overlapping clustering process until no more message sequences exist, thereby returning a failure pattern of interaction coordination and a clustered log set. The method for analyzing coordination disorders based on a time pattern according to claim 10, comprising:

14. The estimating step includes: estimating a location of a suspicious code with respect to a system of systems coordination protocol code from the extracted interaction coordination failure pattern; The method for analyzing coordination disorders based on a time pattern according to claim 1 , comprising:

15. The estimating step includes: Estimating the location of suspicious code using a code coverage calculation method for configuration system level operations The method for analyzing coordination disorders based on a time pattern according to claim 14, comprising:

16. The estimating step includes: measuring code coverage by executing configuration system level tasks to build a code coverage set that records the lines of code executed for each task; The method for analyzing coordination disorders based on a time pattern according to claim 14, comprising:

17. The estimating step includes: and ranking the cooperation protocols according to the degree of suspiciousness of the cause of the fault using the constructed code range set. The method for analyzing temporal pattern-based coordination disorders according to claim 16, comprising:

18. The estimating step includes: Prioritizing code statements that are repeatedly executed in a configuration system level task associated with an interaction coordination failure pattern using SeqOverlap, which calculates the degree of suspiciousness of a failure cause based on the number of sequential overlaps. The method for analyzing temporal pattern-based coordination disorders according to claim 16, comprising:

19. A computer program recorded on a computer-readable recording medium for executing a method for analyzing a coordinated fault based on a time pattern in a system of systems (SOS) executed in a computer device, The method for analyzing coordination failures based on a time pattern in a system of systems includes: Extracting an interaction coordination failure pattern by coordination failure analysis in an interaction model generated from an interaction log executed in the system of systems; estimating an error location of an interaction bug from the extracted interaction coordination failure pattern; A computer program recorded on a computer-readable recording medium, comprising:

20. 1. A computing device comprising: At least one processor configured to execute computer-readable instructions contained in the memory. Including, The at least one processor Extracting interaction coordination failure patterns by coordination failure analysis in an interaction model generated from an interaction log executed in a system of systems; estimating an error location of an interaction bug from the extracted interaction coordination failure pattern; A computer device comprising:

Images