Electronic device conflict resolution method based on behavioral timing causal inference and server

Abstract

This application provides a method and server for resolving electronic device conflicts based on behavioral temporal causal inference. The method includes: performing behavioral event discretization processing on the device behavior data stream generated by the electronic device cluster within a preset monitoring period to generate a set of device behavior event sequences; generating a set of cross-device resource usage conflict relationship edges based on the overlapping time periods of the occupation of the same behavior-related resource field by behavioral event fragment units between different device identifier fields; generating a behavioral temporal causal structure graph using the set of device behavior event sequences as the temporal skeleton and the set of resource usage conflict relationship edges as causal constraint edges; starting from the conflict node pairs with directed edges connecting resource usage conflict relationships in the behavioral temporal causal structure graph, tracing back along the edge connections between nodes to the original triggering behavior node that does not match any directed edge connection of resource usage conflict relationships, determining the tracing path as the conflict root cause propagation link, and generating a conflict resolution behavior instruction sequence accordingly.

Description

Technical Field

[0001] This application relates to the field of data analysis technology, and in particular to a method and server for resolving electronic device conflicts based on behavioral temporal causal inference. Background Technology

[0002] With the rapid development of data centers, smart manufacturing, and the Internet of Things, it has become commonplace for device clusters, composed of numerous electronic devices, to collaborate and complete complex tasks. During cluster operation, devices compete for limited resources such as shared storage, network bandwidth, and bus channels. Existing resource scheduling methods typically employ priority-based preemptive scheduling, time-slice-based round-robin scheduling, or lock-based mutual exclusion control. When multiple devices request the same resource at similar times, a centralized scheduler decides resource allocation based on preset priorities or first-come-first-served rules, with devices failing to acquire the resource entering a waiting queue. Other methods mitigate momentary conflicts by rearranging resource requests or dynamically adjusting the task execution rhythm of devices. However, these existing methods focus on immediate adjudication and mitigation at the moment of conflict, failing to delve into the deeper causal chains of behavior that trigger conflict, resulting in mitigation measures only addressing the surface-level conflict. Summary of the Invention

[0003] This application provides a method and server for resolving electronic device conflicts based on behavioral temporal causal inference, which is used to further explore the deep behavioral causal chain that causes the conflict and avoid the resolution measures from only acting on the surface of the conflict.

[0004] This application provides, in one aspect, a method for resolving electronic device conflicts based on behavioral temporal causal inference, applied to an electronic device conflict resolution server. The method includes: Acquire device behavior data streams generated by the electronic device cluster during a preset monitoring period; The device behavior data stream is subjected to behavior event discretization processing. Device behavior record units with the same behavior type field and continuous time sequence under the same device identifier field are aggregated into behavior event fragment units, generating a set of device behavior event sequences grouped by the device identifier field. For each behavior event segment unit in the device behavior event sequence set, extract the behavior-related resource field it occupies, and generate a cross-device resource usage conflict relationship edge set based on the overlapping time period relationship of behavior event segment units occupying the same behavior-related resource field among different device identifier fields; Using the set of device behavior event sequences as the temporal skeleton and the set of resource usage conflict edges as causal constraint edges, a behavior temporal causal structure graph is generated. Starting from the conflict node pair with directed edge connection of resource usage conflict relationship in the behavior temporal causal structure graph, trace backward along the edge connection between nodes to the original trigger behavior node that does not match any directed edge connection of resource usage conflict relationship. The tracing path from the original trigger behavior node to the conflict node pair is determined as the conflict root cause propagation link. Based on the behavior type field and behavior associated resource field of each behavior event segment unit in the conflict root cause propagation link, generate a conflict resolution behavior instruction sequence for the device identifier field associated with the conflict node pair.

[0005] One embodiment of this application provides an electronic device conflict resolution server, including: A processor; a storage device having a computer program stored thereon; a network interface for providing network communication functions; when the computer program is executed by the processor, the processor enables the processor to implement any of the described electronic device conflict resolution methods based on behavioral temporal causal inference.

[0006] One embodiment of this application provides a readable storage medium storing a program or instructions, which, when executed by a processor, implements the steps of the electronic device conflict resolution method based on behavioral temporal causal inference.

[0007] Therefore, the embodiments of this application have the following beneficial effects: by discretizing and aggregating device behavior data streams into behavior event fragment units, and generating a resource usage conflict relationship edge set based on the overlapping time periods of the behavior event fragment units for the same behavior-related resource field between different device identifier fields, a behavior temporal causal structure graph is constructed using the device behavior event sequence set as the temporal skeleton and the resource usage conflict relationship edge set as the causal constraint edge. This achieves a unified graph structured representation of the temporal evolution of device cluster behavior and resource conflict relationships. Then, starting from the conflict node pairs with directed edges connecting resource usage conflict relationships in the behavior temporal causal structure graph, the process traces backward to the original triggering behavior node that does not match any directed edge connecting resource usage conflict relationships. This tracing path is determined as the conflict root cause propagation link, enabling the resolution behavior instruction sequence to directly act on the causal source of the conflict rather than the conflict manifestation, fundamentally improving the accuracy and efficiency of resolving resource conflicts in electronic device clusters. Attached Figure Description

[0008] To more clearly illustrate the technical solutions in the embodiments or related technologies of this application, the accompanying drawings used in the description of the embodiments or related technologies will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0009] Figure 1 This is a flowchart of an electronic device conflict resolution method based on behavioral temporal causal inference provided in an embodiment of this application.

[0010] Figure 2 This is a schematic diagram of the basic structure of an electronic device conflict resolution server provided in an embodiment of this application.

[0011] Figure 3 This is a functional block diagram of an electronic device conflict resolution device provided in an embodiment of this application. Detailed Implementation

[0012] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of this application.

[0013] Please see Figure 1 , Figure 1 This is a flowchart of an electronic device conflict resolution method based on behavioral temporal causal inference provided in an embodiment of this application. The method can be executed by an electronic device conflict resolution server, or by both the electronic device conflict resolution server and the server. The method may include steps 110-150.

[0014] This application's embodiments can be applied to scenarios involving the resolution of competition for shared storage bandwidth among different computing nodes within a data center. The data center deploys a cluster of computing nodes and a shared storage array. Each computing node independently runs various types of data processing tasks, including data read tasks, data write tasks, log synchronization tasks, and cache refresh tasks. When multiple computing nodes initiate resource requests for the same storage volume or the same network link at similar times, improper resource scheduling will lead to resource usage conflicts, manifesting as a sharp increase in task response latency and a decrease in throughput for some nodes.

[0015] This application embodiment discretizes and aggregates the device behavior data streams generated by each computing node within a preset monitoring period, extracts behavior event sequences grouped by computing nodes, and then generates a resource usage conflict relationship edge set based on the overlapping time periods of resource occupancy associated with the same behavior between nodes. The behavior event sequences are used as the temporal skeleton, and the resource usage conflict relationship edge set is used as the causal constraint edge to generate a behavior temporal causal structure graph. Then, starting from the conflicting node pairs with conflicting relationships, the method traces backward along the edge connections between nodes to the original triggering behavior node that does not match any directed edge connection for resource usage conflict, determining the root cause propagation path of the conflict, and generating a conflict resolution behavior instruction sequence for both computing nodes involved in the conflict. This method can reveal the causal transmission path of resource conflicts at a fine-grained level, enabling the resolution instructions to act on the source of the conflict, rather than merely temporarily avoiding the surface of the conflict.

[0016] To clearly explain the technical solutions of the embodiments of this application, some technical terms will be explained below: (1) Equipment behavior data flow: an ordered set of equipment behavior record units formed by each computing node according to a globally unified time sequence within a preset monitoring period; (2) Behavioral event fragment unit: A behavioral event description unit with start and end times and duration after aggregating the recording units of the same behavior type of the same device; (3) Single device behavior event sequence: The sequence of behavior evolution trajectory of the device formed by arranging the behavior event segments of the same device in ascending order according to the start time of the event; (4) Behavior-related resource field: The deduplicated set of storage volume identifiers or network link identifiers actually occupied by the behavior event fragment unit during its duration; (5) Resource usage conflict relationship edge set: a set of directed edges generated by cross-device behavioral events due to overlapping time periods of occupying the same resource, with the edge direction pointing from the earlier occupying to the later occupying; (6) Temporally transitive directed edges: Directed edges that connect temporally adjacent behavioral event segments within the same device, representing the natural temporal inheritance dependency between behaviors; (7) Behavioral temporal causal structure diagram: a heterogeneous graph structure that integrates temporal dependency edges and resource conflict edges with behavioral event fragment units as nodes, representing the relationship between behavioral evolution and conflict influence; (8) Conflict node pair: Two node units directly connected by a resource conflict edge, corresponding to the behavioral events of the conflict source end and the conflict target end respectively; (9) Original triggering behavior node: In the reverse tracing, there is no node that has any incoming resource conflict edge or time-series transmission conflict edge, that is, the upstream root cause node of the conflict causal chain; (10) Conflict root cause propagation chain: an ordered sequence of nodes from the original triggering behavior node to the conflict target end node unit, which fully depicts the entire process of conflict generation and propagation.

[0017] Step 110: Obtain the device behavior data stream generated by the electronic device cluster during the preset monitoring period.

[0018] In this step, the electronic device cluster specifically refers to the cluster of compute nodes within the data center that are under unified management. Each compute node has a unique node identifier as its device identifier field, DevID. The preset monitoring period is set by operations and maintenance personnel based on the periodic characteristics of the cluster's workload, for example, a time window of length Tmon. The start and end points of this time window are marked using a Coordinated Universal Time (UTC) format timestamp. Within the preset monitoring period, the monitoring agent process running on each compute node collects information about the tasks currently being executed by the node in a polling manner. The collection process continues continuously at a millisecond-level granularity, generating one device behavior record unit for each collection.

[0019] The device behavior record unit consists of a four-tuple field: Device Identifier (DevID), which is a string representing the node identifier of the compute node, such as CNodeA, CNodeB, or CNodeC; Behavior Type (ActType), which is an enumerated value describing the type of the current task operation, including but not limited to ReadOp for data reading, WriteOp for data writing, SyncOp for log synchronization, and FlushOp for cache refresh; Behavior Occurrence Time (TimeStamp), which is the precise system clock value when the agent process collected the record; and Behavior Associated Resource (ResSet), which is a set of storage volume identifiers or network link identifiers occupied by the operation, such as VolM or LinkN.

[0020] The monitoring agent processes on each computing node send the generated device behavior record units to the electronic device conflict resolution server (server) executing the method in real time. The data receiving module on the server merges and arranges the record units from different computing nodes in ascending order according to the behavior occurrence time field they carry, forming a cross-node, globally unified sorted device behavior data stream. The record units in the device behavior data stream are stored sequentially in the server's memory buffer. In addition to carrying the aforementioned four-tuple fields, each record unit is also appended with a globally unique record serial number GlbSeqNo upon receipt, so as to be traced and located in subsequent processing. The data receiving module continues to run until the preset monitoring period ends, and then persists all device behavior record units in the memory buffer to form the final device behavior data stream obtained in this step.

[0021] Step 120: Perform behavior event discretization processing on the device behavior data stream, and aggregate device behavior record units with the same behavior type field and continuous time sequence under the same device identifier field into behavior event fragment units, and generate a set of device behavior event sequences grouped by the device identifier field.

[0022] After obtaining the device behavior data stream, the device behavior recording units in the data stream are snapshot-like records of the instantaneous state of each computing node. Since the monitoring agent process may collect the same behavior type of recording units multiple times consecutively when the same computing node is performing a relatively continuous operation, directly performing cross-node resource conflict analysis based on the recording units will lead to a large number of redundant conflict judgments and will not accurately reflect the duration attribute of the behavior.

[0023] Therefore, this step performs discretization aggregation processing on the device behavior data stream, folding the temporally continuous and behavior-type unchanged sequence of record units into behavior event fragment units with start time, end time, and duration attributes, and grouping the aggregation results according to the device identifier field.

[0024] Step 121: The device behavior data stream is split into multiple single device behavior record sub-streams according to the different values ​​of the device identifier field. Each single device behavior record sub-stream corresponds uniquely to a value of the device identifier field.

[0025] The server first iterates through the device behavior data stream obtained in step 110, reading the value of the DevID field from each device behavior record. The server maintains a key-value mapping structure where the key is the DevID string and the value is a variable-length list of records. For the currently iterated record, the server calculates the hash value of its DevID string to locate the corresponding key in the mapping structure and appends the record to the end of the list associated with that key. If the mapping structure does not yet contain a key corresponding to the current DevID, the server first creates a new entry with that DevID as the key, initializes an empty list, and then appends the current record to that list.

[0026] When the entire device behavior data stream has been traversed, the record list container associated with each key in the mapping structure stores all device behavior record units belonging to the same compute node. Since the device behavior data stream itself is merged in ascending order according to the behavior occurrence time field, the record units within each record list container naturally maintain this ascending order as well. The server extracts the sequence of record units from each record list container to form a single device behavior record substream. If the device behavior data stream involves P different compute nodes, this step generates P single device behavior record substreams, each uniquely corresponding to a DevID.

[0027] Step 122: For each single device behavior record sub-stream, traverse the device behavior record units in the single device behavior record sub-stream one by one in the increasing direction of the behavior occurrence time field, and compare whether the behavior type field of the currently traversed device behavior record unit is the same as that of the previous adjacent device behavior record unit.

[0028] For any single-device behavior record substream generated in step 121, the server starts a traversal cursor, initially pointing to the first device behavior record unit in the substream. For the first device behavior record unit, the server creates a new behavior event fragment temporary storage container. The container's data structure is a dynamic array that can hold multiple device behavior record units, and the first record unit is placed into this array. At the same time, the ActType field value of the first record unit is recorded as the current active behavior type CurAct.

[0029] The cursor then moves to the second record unit. Starting from the second record unit, the server extracts the ActType field value of the record unit currently pointed to by the cursor and performs a string equality comparison with CurAct. The comparison operation is performed using byte stream comparison, rather than numerical comparison, to ensure accurate matching of behavior type enumeration values.

[0030] Step 123: If the behavior type field of the currently traversed device behavior record unit is the same as the behavior type field of the previous adjacent device behavior record unit, then the currently traversed device behavior record unit is assigned to the same behavior event fragment temporary storage container as the previous adjacent device behavior record unit.

[0031] When the string equality comparison in step 122 returns true, it indicates that the operation type performed by the current compute node has not changed, and the current record unit is a continuation of the behavior described by the previous record unit. The server appends the current record unit directly to the end of the dynamic array corresponding to the temporary storage container for the currently active behavior event fragment. The append operation does not change the value of CurAct, nor does it trigger the creation of any new containers. The server then updates the cursor to point to the next record unit in the single-device behavior record substream and returns to step 122 to continue execution.

[0032] Step 124: If the behavior type field of the currently traversed device behavior record unit is different from the behavior type field of the previous adjacent device behavior record unit, then close the behavior event fragment temporary storage container where the previous adjacent device behavior record unit is located, generate a behavior event fragment unit, and at the same time create a new behavior event fragment temporary storage container and use the currently traversed device behavior record unit as the first element of the new behavior event fragment temporary storage container.

[0033] When the string equality comparison in step 122 returns a false value, it indicates that the operation type of the compute node has changed, the previous operation has been terminated, and the new operation has started. The server immediately performs a closing operation on the temporary storage container for the currently active behavior event fragment. The closing operation includes: marking the dynamic array corresponding to the container as read-only to prevent any subsequent appending of record units; and assigning a globally unique behavior event fragment unit identifier, EvtSegID, to the closed container. The identifier is generated by concatenating the compute node's DevID with an incrementing fragment sequence number. At this point, a complete behavior event fragment unit is generated.

[0034] Next, the server creates a new empty behavior event fragment temporary container, whose dynamic array is initially empty, and adds the record unit that triggered the behavior type change as the first element of this new container. Simultaneously, the server updates the CurAct field to the ActType field value of the current record unit, so that it can serve as a new reference benchmark in the next round of comparison. If the current cursor has reached the end of the single-device behavior record substream, the server directly closes the currently active temporary container, generating the last behavior event fragment unit, and ends the traversal processing of that substream.

[0035] Step 125: Combine the event timing field of each closed generated behavior event fragment unit to generate the device behavior event sequence set.

[0036] After each single-device behavior record substream has been traversed and its segments aggregated, the server obtains several behavior event segment units corresponding to each computing node. Each behavior event segment unit currently contains only one or more device behavior record units belonging to that segment. To support the subsequent calculation of resource occupancy time overlap relationships, it is necessary to extract the overall timing description information and resource occupancy description information of the behavior event segment from the record units contained within the segment.

[0037] Step 1251: For each closed generated behavior event fragment unit, extract the behavior occurrence time field of the first device behavior record unit in the behavior event fragment temporary storage container as the event start time field, extract the behavior occurrence time field of the last device behavior record unit in the behavior event fragment temporary storage container as the event end time field, and use the time span between the event start time field and the event end time field as the event duration field.

[0038] The server accesses the dynamic array associated with the behavior event fragment unit, reads the TimeStamp field value of the first device behavior record unit (the first element of the array header), and assigns it to the event start time field TStart of that behavior event fragment unit.

[0039] Next, the TimeStamp field value of the last element of the array, i.e., the last device behavior record unit, is read and assigned to the event end time field TEnd of that behavior event fragment unit. Based on TStart and TEnd, the server calculates the event duration field TDur by subtracting the time value corresponding to TStart from the time value corresponding to TEnd, resulting in the duration in milliseconds.

[0040] Since the record units within the same segment are arranged in ascending order according to the time of occurrence of the action, TStart must be less than or equal to TEnd. When the segment contains only a single record unit, TStart is equal to TEnd, and TDur takes the value of zero.

[0041] Step 1252: Perform deduplication and merging of the behavior-related resource fields of all device behavior record units in the behavior event fragment temporary storage container to generate a set of behavior-related resource fields occupied by the behavior event fragment unit during its duration.

[0042] Multiple device behavior record units within a behavior event segment unit may record the same or different resource identifiers in their respective ResSet fields. The server iterates through the dynamic array corresponding to the segment, parses the ResSet field in each record unit, extracts each resource identifier contained in the ResSet one by one, and puts them into a temporary resource identifier set container. This container adopts a set data structure and automatically eliminates duplicate resource identifiers.

[0043] After the traversal is complete, the resource identifiers retained in the collection container represent all the resources occupied by the compute node during the duration of the behavior event segment. The server stores this collection container as the behavior-associated resource field set ResSetAgg for this behavior event segment unit.

[0044] Step 1253: Combine and encapsulate the event start time field, event end time field, event duration field, and behavior-related resource field set with the device identifier field and behavior type field corresponding to the behavior event fragment unit to generate a behavior event fragment unit with a complete event attribute description.

[0045] The server combines the TStart, TEnd, and TDur generated in step 1251, and the ResSetAgg generated in step 1252, with the DevID and ActType extracted from the first record unit within the fragment. This combination forms a data structure with a complete set of attributes. This data structure contains at least the following members: DevID, ActType, TStart, TEnd, TDur, and ResSetAgg. This data structure is the final behavioral event fragment unit, which retains the original computing node device ownership information and also describes the duration and resource consumption information of the behavioral event.

[0046] Step 1254: Arrange all behavior event fragment units under the same device identifier field in ascending order according to the event start time field to generate a single device behavior event sequence.

[0047] For each compute node DevID, the server collects all behavioral event fragments belonging to that DevID and constructs a fragment list. The server sorts this list based on the TStart member value carried by each fragment, in ascending order from smallest to largest. After sorting, the behavioral event fragments in the fragment list are arranged in chronological order of their occurrence, resulting in a complete single-device behavioral event sequence that reflects the behavioral evolution trajectory of the compute node within a preset monitoring period.

[0048] Step 1255: Summarize the single device behavior event sequences corresponding to all device identifier fields to generate the device behavior event sequence set grouped by device identifier field.

[0049] The server stores each single-device behavior event sequence generated in step 1254 into a mapping structure, using DevID as the key and the sequence itself as the value. This mapping structure is the final set of device behavior event sequences grouped by the device identifier field generated in this step. The sequence set inherently contains all behavior event information of all computing nodes within the preset monitoring period, and is logically isolated by device. At the same time, it retains the precise timing information and resource usage information of each behavior event segment, providing a structured input for cross-device resource conflict detection.

[0050] Step 130: Extract the behavior-related resource field occupied by each behavior event segment unit in the device behavior event sequence set, and generate a cross-device resource usage conflict relationship edge set based on the overlapping time periods of the behavior event segment units occupying the same behavior-related resource field among different device identifier fields.

[0051] After obtaining the set of device behavior event sequences, the server needs to further identify the temporal conflict relationships between different computing nodes due to competition for the same resources. The essence of resource conflict is that two or more computing nodes request the same resource within the same time interval, or that overlapping resource usage occurs. This step systematically generates a set of directed edges describing cross-node resource usage conflict relationships by expanding resource fields, globally registering, sorting by time period, and determining overlap in the behavior event fragment units.

[0052] Step 131: Traverse the single device behavior event sequence corresponding to each device identifier field in the device behavior event sequence set, perform resource field expansion processing on each behavior event fragment unit in the single device behavior event sequence, and expand the set of behavior-related resource fields carried by the behavior event fragment unit into multiple independent behavior-related resource field items.

[0053] The server iterates through the device behavior event sequence set generated in step 120. For each DevID corresponding to a single device behavior event sequence in the sequence set, the server then accesses each behavior event fragment unit contained in the sequence one by one. For each behavior event fragment unit, the server reads its ResSetAgg member. Since ResSetAgg is a collection structure, it may contain zero or one or more resource identifiers. For each resource identifier ResItem in ResSetAgg, the server generates an expanded record. This expanded record contains the EvtSegID of the current behavior event fragment unit, its corresponding DevID, its TStart, its TEnd, and the resource identifier ResItem. This expansion operation transforms the one-to-many relationship into multiple one-to-one related records, allowing subsequent analysis of its occupancy status independently at the level of a single resource identifier.

[0054] Step 132: Establish a global resource occupancy registration table with the behavior-related resource field item as the index key. Each registration entry in the global resource occupancy registration table includes a resource occupancy device identifier field, a resource occupancy behavior event fragment unit identifier, a resource occupancy start time field, and a resource occupancy end time field.

[0055] The server initializes a global resource occupancy registry in memory. Logically, this registry is a key-value mapping structure, where the index key is the resource identifier string `ResItem`, and the mapped value is a list of registry entries. Each registry entry is a structure containing at least the following members: a resource occupancy device identifier field `OccDevID`, used to record the DevID of the compute node occupying the resource; a resource occupancy behavior event fragment unit identifier `OccEvtSegID`, used to record the identifier of the specific behavior event fragment unit occupying the resource; a resource occupancy start time field `OccTStart`, used to record the start time of the occupancy behavior; and a resource occupancy end time field `OccTEnd`, used to record the end time of the occupancy behavior.

[0056] Step 133: For each behavior-related resource field item obtained from expansion, register the device identifier field, behavior event fragment unit identifier, event start time field, and event end time field corresponding to the behavior-related resource field item to the registration entry list under the corresponding index key in the global resource occupancy registration table.

[0057] The server iterates through all expanded records generated in step 131. For each expanded record, it extracts the ResItem, DevID, EvtSegID, TStart, and TEnd. Using ResItem as the index key, it locates or creates the corresponding list of entries in the global resource occupancy registry. The server constructs a new entry, assigning OccDevID to DevID, OccEvtSegID to EvtSegID, OccTStart to TStart, and OccTEnd to TEnd, and appends this new entry to the end of the target entry list.

[0058] When all expanded records have been processed, each resource identifier in the global resource occupancy registration table contains the registration information of all computing node behavior event fragments that have occupied that resource within the preset monitoring period.

[0059] Step 134: Sort all entries under the associated resource field item of the same row in the global resource occupancy registration table according to the order of the resource occupancy start time field, and generate the occupancy time sequence of the associated resource field item of that row.

[0060] For each resource identifier (ResItem) in the global resource occupancy registration table, the server sorts the corresponding list of entries. The sorting is based on the value of the OccTStart member of each entry, and the sorting direction is ascending. After sorting, the entries in the registration list are arranged sequentially from earliest to latest according to the start time of the occupancy behavior. This sorted list constitutes the occupancy time sequence for that resource identifier. The occupancy time sequence reflects how occupancy requests for that resource arrive and continue in chronological order within a preset monitoring period.

[0061] Step 135: Select two adjacent registration entries in the occupied time period sequence, and compare whether there is a time overlap region between the resource occupation end time field of the previous registration entry and the resource occupation start time field of the next registration entry. The time overlap region is used to indicate that the resource occupation end time field of the previous registration entry is later than the resource occupation start time field of the next registration entry.

[0062] The server iterates through adjacent pairs of registered entries in the occupancy time sequence. For the k-th entry Entryk and the (k+1)-th entry Entryk+1 in the sequence, the server reads the OccTEnd member value TEndk of Entryk and the OccTStart member value TStartk+1 of Entryk+1, respectively. The condition for determining a time overlap region is that TEndk is later than TStartk+1. This determination is made by comparing the two time values: if the value corresponding to TEndk is greater than the value corresponding to TStartk+1, then a time overlap region is determined to exist; otherwise, no time overlap region is determined to exist. The existence of a time overlap region indicates that when the later occupancy behavior begins, the previous occupancy behavior has not yet ended, and the two overlap in the time dimension.

[0063] Step 136: If there is a time overlap area between the previous registration entry and the next registration entry, and the resource-occupying device identifier field in the previous registration entry is different from the resource-occupying device identifier field in the next registration entry, then a directed edge of resource usage conflict relationship is generated from the behavior event fragment unit corresponding to the previous registration entry to the behavior event fragment unit corresponding to the next registration entry.

[0064] When step 135 determines that a time overlap region exists, the server further reads the OccDevID member value Devk from Entryk and the OccDevID member value Devk+1 from Entryk+1. The server compares Devk and Devk+1 for similarity. If they are different, it indicates that the time overlap region is caused by two different computing nodes, constituting a cross-device resource usage conflict event. At this time, the server generates a directed edge for the resource usage conflict relationship. The direction of this directed edge is set from the behavior event segment unit corresponding to Entryk to the behavior event segment unit corresponding to Entryk+1, that is, from the behavior event segment unit associated with the node that occupies the resource first to the behavior event segment unit associated with the node that occupies the resource later. The direction setting reflects the temporal logical relationship of the conflict: the earlier occupation behavior constitutes resource crowding out of the later occupation behavior.

[0065] Step 137: Extract the starting behavior event fragment unit identifier and the ending behavior event fragment unit identifier of the directed edge of the resource use conflict relationship, and attach the behavior associated resource field item that caused the conflict as the conflict resource identifier to the edge attribute of the directed edge of the resource use conflict relationship.

[0066] For each directed edge representing a resource usage conflict generated in step 136, the server records the starting node identifier SrcEvtSegID, whose value is the OccEvtSegID member value corresponding to Entryk; and the ending node identifier DstEvtSegID, whose value is the OccEvtSegID member value corresponding to Entryk+1. Simultaneously, the server appends the currently processed resource identifier ResItem as the conflicting resource identifier ConflictRes to the edge attribute structure of this directed edge. In addition to ConflictRes, the edge attribute structure also records the start and end times of the overlapping time region. The start time of the overlap is taken as TStartk+1, and the end time of the overlap is taken as the smaller value between TEndk and TEndk+1, to accurately depict the specific time window in which the conflict occurs.

[0067] Step 138: Collect and organize all the directed edges of resource usage conflict relationships and their additional edge attributes to generate the cross-device resource usage conflict relationship edge set.

[0068] The server aggregates all directed edges of resource usage conflict relationships generated in steps 136 and 137 into a set structure. Each edge in this set structure carries SrcEvtSegID, DstEvtSegID, and edge attribute information including ConflictRes. This set structure is the cross-device resource usage conflict relationship edge set finally output by this step. This edge set explicitly describes which behavioral event segments between which computing nodes have time overlap conflicts due to competition for the same resource within the preset monitoring period.

[0069] Step 140: Using the set of device behavior event sequences as the temporal skeleton and the set of resource usage conflict relationship edges as causal constraint edges, generate a behavior temporal causal structure graph.

[0070] After acquiring a set of device behavior event sequences describing the evolution of each computing node's behavior and a set of resource usage conflict relationship edges describing cross-node resource conflict relationships, the server fuses these two heterogeneous pieces of information to construct a unified behavioral temporal causal structure graph. This structure graph uses behavioral event fragment units as nodes and temporal dependencies and resource conflict relationships between behavioral events as edges, thus realizing a graph-structured representation of the behavior of the device cluster and its mutual influence.

[0071] Step 141: Transform each behavior event fragment unit in the device behavior event sequence set into an independent node unit in the initial causal structure graph, and assign a globally unique node identifier to each node unit.

[0072] The server iterates through the device behavior event sequence set generated in step 120, extracting each behavior event fragment unit. For each behavior event fragment unit, the server creates a corresponding independent node unit in the graph. The internal data storage of the node unit contains all the attribute members of its corresponding behavior event fragment unit, namely DevID, ActType, TStart, TEnd, TDeur, and ResSetAgg. The server assigns a globally unique node identifier NodeID to each newly created node unit. The NodeID can be generated based on the original EvtSegID of the behavior event fragment unit, for example, by appending a fixed prefix character to the EvtSegID string to form the NodeID, or by using a hash algorithm to hash the EvtSegID to obtain a fixed-length NodeID value.

[0073] Step 142: Map the device identifier field of each behavior event fragment unit to the device affiliation attribute of the node unit, map the behavior type field to the behavior category attribute of the node unit, map the event start time field to the timing start attribute of the node unit, and map the event end time field to the timing end attribute of the node unit.

[0074] To enable efficient access to key attributes of node units during subsequent graph traversal and path tracing, the server performs semantic mapping on the data members of node units, organizing them into a standardized attribute structure. Specifically, the DevID member within a node unit is mapped to the device ownership attribute NodeDev; the ActType member is mapped to the behavior category attribute NodeAct; the TStart member is mapped to the timing start attribute NodeTStart; and the TEnd member is mapped to the timing end attribute NodeTEnd. This mapping operation does not change the essential content of the data but provides a consistent attribute naming interface for data access, facilitating its use by graph processing algorithms.

[0075] Step 143: For the node units corresponding to two temporally adjacent behavior event segments in the same single device behavior event sequence, generate a temporally transitive directed edge from the temporally earlier node unit to the temporally later node unit, and mark the edge type attribute of the temporally transitive directed edge as a temporally dependent edge.

[0076] For each single-device behavior event sequence, the server processes each pair of adjacent fragment units sequentially according to their order in the sequence. Let the node units corresponding to two adjacent fragment units be Nodei and Nodei+1, with Nodei preceding Nodei+1 in the sequence. The server adds a directed edge to the behavior temporal causal structure graph, originating from Nodei and pointing to Nodei+1. The edge type attribute of this directed edge is marked as a temporal dependency edge, denoted as EdgeTypeSeq. Temporal dependency edges represent the natural temporal sequence relationship between behavior events within the same device and are a crucial foundational framework for causal inference.

[0077] Step 144: Traverse each directed edge of the resource use conflict relationship in the resource use conflict relationship edge set, and locate the corresponding start node unit and end node unit in the initial causal structure graph according to the start behavior event segment unit identifier and end behavior event segment unit identifier recorded in the directed edge of the resource use conflict relationship.

[0078] The server iterates through each directed edge in the resource usage conflict edge set generated in step 130. For the currently traversed directed edge, it reads its SrcEvtSegID and DstEvtSegID fields. The server uses these two field values ​​to perform a lookup in the node set of the initial causal structure graph. The lookup process can be accelerated by maintaining a mapping index from EvtSegID to NodeID: when creating node units in step 141, the server synchronously records the correspondence between EvtSegID and NodeID. In this step, the server retrieves the mapping index using SrcEvtSegID as the key to obtain the corresponding starting node unit NodeSrc; and retrieves the mapping index using DstEvtSegID as the key to obtain the corresponding ending node unit NodeDst.

[0079] Step 145: Add a directed edge corresponding to the resource usage conflict relationship between the starting node unit and the ending node unit, mark the edge type attribute of the directed edge as a resource conflict edge, and write the conflict resource identifier attached to the directed edge into the edge attribute of the directed edge.

[0080] In the behavioral temporal causal structure graph, the server adds a new directed edge between NodeSrc and NodeDst, located in step 144, with the direction consistent with the original directed edge indicating a resource usage conflict, i.e., from NodeSrc to NodeDst. The server marks the edge type attribute of this directed edge as a resource conflict edge, denoted as EdgeTypeConf.

[0081] At the same time, the server reads the edge attribute information carried by the original directed edges of resource usage conflict relationships, including the conflicting resource identifier ConflictRes and the overlapping time window information, and copies the above information completely into the edge attribute structure of the newly added directed edges of conflict relationships.

[0082] Step 146: Indirect conflict path detection is performed on the initial causal structure graph. Based on the detection results, directed edges for derived conflicts are added, and the behavior temporal causal structure graph is obtained by arranging the topology.

[0083] In addition to explicit conflict edges directly caused by overlapping resource usage periods, behavioral temporal causal structure graphs may also contain indirect conflict relationships propagated through temporal dependency edges. This step detects and makes explicit these indirect conflicts to improve the representation of the causal graph.

[0084] Step 1461: Detect whether there is an indirect conflict path in the initial causal structure graph that is connected by a time-transmission directed edge and simultaneously by a conflict relationship directed edge. If the starting node unit reaches the intermediate node unit through at least one time-transmission directed edge and the intermediate node unit is connected to the ending node unit through a conflict relationship directed edge, then add a derived conflict directed edge from the starting node unit to the ending node unit between the starting node unit and the ending node unit, and mark the edge type attribute of the derived conflict directed edge as a time-transmission conflict edge.

[0085] The server starts a graph pattern matching engine to scan the initial causal structure graph for path patterns. The target path pattern to be scanned is: the starting node unit NodeA reaches the intermediate node unit NodeM through a directed edge with the edge type attribute of temporal dependency by one or more hops, and NodeM has a directed edge with the edge type attribute of resource conflict pointing to the terminating node unit NodeB.

[0086] When a path matching the pattern is found, the server determines that the behavior event represented by NodeA has indirectly caused a resource conflict to the behavior event represented by NodeB through temporal propagation. At this time, the server adds a derived conflict directed edge from NodeA directly to NodeB in the behavior temporal causal structure graph. The edge type attribute of this derived conflict directed edge is marked as a temporal propagation conflict edge, denoted as EdgeTypeTransConf.

[0087] Step 1462: Write the sequence of intermediate node units constituting the derivation conflict propagation process and the original edge type combination corresponding to each path segment into the edge attributes of the directed edge of the derivation conflict, so as to record the temporal propagation path of the conflict.

[0088] For each newly added directed edge representing a derived conflict, the server adds a propagation path record field to its edge attribute structure. This field stores the complete sequence of nodes traversed from NodeA to NodeB, such as NodeA, NodeX1, NodeX2, NodeM, and NodeB. Simultaneously, it records the edge type of each directed edge connecting these nodes, forming an edge type sequence, such as temporal dependency edge, temporal dependency edge, temporal dependency edge, and resource conflict edge. This record allows for a clear reconstruction of how the conflict propagated through the temporal chain during subsequent root cause tracing.

[0089] Step 1463: Perform topological restructuring on all node units and their connected directed edges in the initial causal structure graph, and combine the restructured set of node units and the set of directed edges into the behavioral temporal causal structure graph.

[0090] The server performs a final cleanup of the expanded causal graph obtained through the above steps. This cleanup includes removing isolated node units, merging duplicate directed edges of the same type, and rebuilding the indexes of node and edge units to optimize the storage structure. After cleanup, the server encapsulates the node unit set V and the directed edge set E into a graph data structure G, where G equals the ordered pair V followed by commas E. Graph G is the final generated behavioral temporal causal structure graph. Each node unit in the graph retains its NodeDev, NodeAct, NodeTStart, and NodeTEnd attributes; each directed edge retains its EdgeType attribute and corresponding edge attribute information.

[0091] Step 150: Starting from the conflict node pair with directed edge connection of resource usage conflict relationship in the behavior temporal causal structure graph, trace backward along the edge connection between nodes to the original trigger behavior node that does not match any directed edge connection of resource usage conflict relationship. Determine the tracing path from the original trigger behavior node to the conflict node pair as the conflict root cause propagation link. Generate a conflict resolution behavior instruction sequence for the device identifier field associated with the conflict node pair based on the behavior type field and behavior associated resource field of each behavior event fragment unit in the conflict root cause propagation link.

[0092] The construction of the behavioral temporal causal structure graph makes root cause analysis of resource conflicts possible. This step utilizes a graph traversal algorithm to trace the causal source of the conflict backward from the known conflict node pairs in the graph, and generates a targeted resolution instruction sequence based on the tracing path to alleviate or resolve the conflict at its root.

[0093] Step 151: In the behavioral temporal causal structure graph, identify all two node units directly connected by directed edges whose edge type attribute is resource conflict edge, and mark the two node units as a set of conflict node pairs, which include conflict source end node unit and conflict target end node unit.

[0094] The server traverses all directed edges in the behavioral temporal causal structure graph G. For each directed edge, it checks whether its EdgeType member value is equal to EdgeTypeConf, i.e., the resource conflict edge. If they are equal, it reads the starting node unit NodeSrc and the ending node unit NodeDst of the directed edge. The server marks NodeSrc and NodeDst as a pair of conflicting nodes.

[0095] In a conflicting node pair, NodeSrc is defined as the conflict source node unit, indicating that its corresponding behavior event has squeezed out the other party's resource usage; NodeDst is defined as the conflict target node unit, indicating that its corresponding behavior event has been squeezed out by the other party's resource usage.

[0096] Step 152: For each pair of conflicting nodes, the conflict source node unit is used as the current tracing start node unit, and the conflict target node unit is used as the current tracing reference node unit. The conflict root cause propagation path temporary list is initialized, and the conflict source node unit and the conflict target node unit are added to the conflict root cause propagation path temporary list in sequence.

[0097] For each pair of conflicting nodes identified in step 151, the server initiates a root cause tracing process separately. During the process initialization phase, the server sets two tracking variables: the CurNode variable is assigned the value of the conflict source end node unit NodeSrc; the RefNode variable is assigned the value of the conflict target end node unit NodeDst.

[0098] Simultaneously, the server creates an empty linear list structure as a temporary list for conflict root cause propagation paths, PathList. The server first appends the node identifier corresponding to RefNode to the end of PathList, and then inserts the node identifier corresponding to CurNode to the head of PathList. At this point, PathList stores two nodes, in order from CurNode to RefNode, reflecting the direct pointing relationship from the conflict source to the conflict target.

[0099] Step 153: Starting from the current tracing start node unit, retrieve all incoming directed edges in the behavioral temporal causal structure graph with the current tracing start node unit as the endpoint of the directed edge, and extract the start node units of all incoming directed edges as a set of candidate predecessor node units.

[0100] In the behavioral temporal causal structure graph G, the server retrieves all incoming directed edges pointing to CurNode, with CurNode as the target. This retrieval can be accomplished by traversing the inverse adjacency list of graph G. For each retrieved incoming directed edge, the server reads the starting node element of the edge and adds it to a temporary candidate predecessor node element set, CandSet. CandSet contains all node elements on the graph that directly point to CurNode.

[0101] Step 154: Select the predecessor node units from the candidate predecessor node unit set that are connected to the current tracing starting node unit by a time-transfer directed edge, a resource conflict edge, or a time-transfer conflict edge, and determine the tracing direction according to the edge type attribute priority. The edge type attribute priority is determined in the order that resource conflict edges take precedence over time-transfer conflict edges, which in turn take precedence over time-transfer directed edges.

[0102] For each candidate predecessor node unit CandNode in CandSet, the server checks the edge type attribute of the directed edge connecting CandNode and CurNode. If the EdgeType of the edge is a resource conflict edge, a timing propagation conflict edge, or a timing dependency edge, then CandNode is considered a valid predecessor node unit.

[0103] When multiple valid predecessor node units exist in the CandSet, the server selects one as the tracing direction based on the preset edge type attribute priority. The priorities, from highest to lowest, are: resource conflict edges, temporal propagation conflict edges, and temporal dependency edges. The server selects the valid predecessor node unit with the highest priority as the selected predecessor node unit SelNode. If multiple candidates with the same highest priority exist, the server further sorts them based on the time interval between the TEnd of their corresponding behavioral event fragment unit and the TStart of the CurNode, selecting the candidate with the shorter time interval to prioritize tracing paths with closer causal relationships.

[0104] Step 155: Select the predecessor node unit selected after determining the tracing direction as the new current tracing starting node unit, insert the selected predecessor node unit into the starting position of the conflict root cause propagation path temporary list, and update the current tracing starting node unit to the new current tracing starting node unit.

[0105] The server assigns the SelNode determined in step 154 ​​to the CurNode variable, completing the update of the current tracing starting node unit. Simultaneously, the server inserts the node identifier corresponding to the SelNode into the head position of the PathList. At this point, the head element of the PathList is the new CurNode, and the length of the PathList increases by one. This operation ensures that the PathList always maintains the reverse order from the continuously backtracking predecessor node to the final conflict target node RefNode.

[0106] Step 156: Based on the cyclic update process of the current tracing starting node unit, determine the original triggering behavior node unit and generate a conflict root cause propagation link node sequence, generate a resolution behavior instruction according to the conflict root cause propagation link node sequence, and determine the conflict resolution behavior instruction sequence.

[0107] Steps 153 to 155 constitute a cyclical iterative process. The server repeatedly executes the above steps, continuously moving backward along the directed edges of the graph until the stopping condition is met, thereby locating the original triggering node of the conflict and generating the final resolution instruction.

[0108] Step 1561: Repeat the steps of retrieving incoming directed edges, filtering predecessor node units, and updating the tracing start node unit until the current tracing start node unit does not have any resource conflict edge connection with the current tracing start node unit as the endpoint in the behavior temporal causal structure graph, and does not have any temporal transmission conflict edge connection with the current tracing start node unit as the endpoint, and determine the current tracing start node unit as the original triggering behavior node unit.

[0109] The server sets the loop termination condition as follows: The CurNode in graph G must not have any directed edges with the incoming edge type attribute of resource conflict, and it must also not have any directed edges with the incoming edge type attribute of temporally propagated conflict. After each update of the CurNode, the server checks whether this condition is met. If it is, the loop terminates, and the CurNode at this point is determined as the original triggering behavior node unit, RootNode. The original triggering behavior node unit represents the upstream resource contention event in the causal chain of this conflict, which is not caused by other nodes and is the root cause of the conflict.

[0110] Step 1562: Extract all node units from the conflict root cause propagation path temporary list, arranged sequentially from the original triggering behavior node unit to the conflict target end node unit, and generate the conflict root cause propagation link node sequence.

[0111] When the loop terminates, the head of PathList stores the node identifier of RootNode, and the tail stores the node identifier of RefNode. The server extracts the node identifier sequence from PathList in its original order, forming an ordered list of node identifiers. This list is the SeqRootCause, the node sequence of the conflict root cause propagation chain. SeqRootCause fully describes the entire process from the root cause event, through a series of temporal transmissions and resource conflict propagation, ultimately leading to the resource occupation of the target node.

[0112] Step 1563: Based on the behavior event fragment unit mapped to each node unit in the conflict root cause propagation link node sequence, sequentially read the behavior type field and behavior associated resource field of each behavior event fragment unit.

[0113] For each node identifier in SeqRootCause, the server locates the corresponding node unit and accesses its original corresponding behavior event fragment unit through the mapping relationship within the node unit. From the behavior event fragment unit, the server reads the ActType and ResSetAgg members. The read ActType and ResSetAgg are organized into two parallel sequences according to the order of SeqRootCause: the behavior type field sequence SeqAct and the resource field sequence SeqRes.

[0114] Step 1564: Based on the causal influence transmission relationship of the behavior type field of each node unit in the conflict root cause propagation link node sequence, generate a first resolution behavior instruction for the device identifier field associated with the conflict source node unit and a second resolution behavior instruction for the device identifier field associated with the conflict target node unit, and combine the first resolution behavior instruction and the second resolution behavior instruction into the conflict resolution behavior instruction sequence.

[0115] The server analyzes the combination patterns of SeqAct and SeqRes, and generates resolution instructions based on a pre-configured resolution strategy library. The resolution strategy library stores mapping rules from conflict root cause behavior types to resolution actions. For example, if the RootNode's NodeAct is WriteOp and its NodeDev is CNodeA, and the conflict target RefNode's NodeDev is CNodeB, the server-generated first resolution action instruction for CNodeA might be adjusting CNodeA's write rate limit or delaying its write task scheduling time; the generated second resolution action instruction for CNodeB might be redirecting CNodeB's read operations to other replica storage volumes. The server combines the first and second resolution action instructions, encapsulating them into a sequentially executed instruction sequence, which is the final conflict resolution action instruction sequence output by this method.

[0116] As another implementation, after generating a sequence of conflict resolution behavior instructions for the conflict node against the associated device identifier field based on the behavior type field and behavior-related resource field of each behavior event segment unit in the conflict root cause propagation chain, the method further includes a pattern solidification and marking step to improve the response timeliness of future conflict determination by utilizing historical conflict data: Step 211: Abstract the sequence of behavior type fields and the sequence of changes in the occupation of behavior-related resource fields of each behavior event segment unit in the conflict root cause propagation chain into conflict mode feature tuples.

[0117] The server performs abstraction processing on the SeqAct and SeqRes sequences obtained in step 1563. The purpose of this abstraction processing is to eliminate the differences in DevIDs of specific nodes and extract a general pattern for the combination of behavior type and resource type. For the SeqAct sequence, the relative order of its behavior type enumeration values ​​is preserved to form the behavior type pattern vector PatAct.

[0118] For a SeqRes sequence, the resource type used by each behavioral event fragment unit is extracted instead of the specific resource identifier, forming a resource type pattern vector PatResType. The server combines PatAct and PatResType to generate a conflict pattern feature tuple PatternTuple. PatternTuple is logically represented as a tuple: left angle bracket PatAct comma PatResType right angle bracket.

[0119] Step 212: Traverse multiple conflict root cause propagation links generated during different preset monitoring periods in the behavior temporal causal structure diagram to count the recurrence frequency of the conflict pattern feature tuples, and mark the conflict pattern feature tuples whose recurrence frequency exceeds the preset pattern emergence threshold as inherent temporal conflict patterns.

[0120] The server maintains a frequency statistics table of conflict patterns spanning multiple preset monitoring periods. Each time a preset monitoring period completes the identification of the conflict root cause propagation link and generates a PatternTuple, the server increments the frequency count of the PatternTuple in the frequency statistics table using the PatternTuple as the key.

[0121] When the cumulative occurrence frequency of a PatternTuple in the frequency statistics table exceeds a preset pattern emergence threshold, the server marks that PatternTuple as an inherent temporal conflict pattern. The preset pattern emergence threshold can be dynamically set according to the cluster size and the amount of historical data; for example, an anomaly detection algorithm based on Poisson distribution can determine a dynamic threshold.

[0122] Step 213: When performing behavior event discretization processing on the device behavior data stream to generate new behavior event fragment units, if the combination of behavior type fields and associated resource field occupancy relationships formed by the new behavior event fragment unit and adjacent behavior event fragment units match the conflict pattern feature tuple in the inherent temporal conflict pattern, then when generating the cross-device resource usage conflict relationship edge set, the directed edge of the resource usage conflict relationship from the new behavior event fragment unit to the adjacent behavior event fragment unit is set as the conflict determination priority response edge.

[0123] In subsequent monitoring cycles, when the server generates a new behavioral event fragment unit in step 120, it monitors in real time whether the combination of local behavioral types and resource usage relationships formed by the newly generated fragment unit and its adjacent fragment units within the same device match the prefix or the whole of a PatternTuple that has been marked as an inherent temporal conflict pattern. If the match is successful, when the server executes step 136, if the adjacent fragment unit overlaps with the resource time period of other devices, it directly sets the priority flag field in the edge attribute of the directed edge of the resource usage conflict relationship generated therefrom to a high priority, instructing the resolution module to respond to the conflict edge with priority, without waiting for the complete root cause tracing process.

[0124] As another implementation, after generating a sequence of conflict resolution behavior instructions for the conflict node against its associated device identifier field based on the behavior type field and behavior-associated resource field of each behavior event segment unit in the conflict root cause propagation chain, the method further includes a resolution effect feedback evaluation step to close the loop and correct subsequent resolution strategies: Step 311: Obtain the updated device behavior data stream generated after the conflict resolution behavior instruction sequence is executed by the electronic device corresponding to the device identifier field; perform the behavior event discretization processing on the updated device behavior data stream to obtain the updated device behavior event sequence set and reconstruct the updated behavior temporal causal structure diagram accordingly.

[0125] After the conflict resolution action instruction sequence is sent to the local agent processes of the computing nodes at the conflict source and conflict target ends for execution, the behavior pattern of the computing nodes will change. The server obtains the updated device behavior data stream generated in the next preset monitoring period. Steps 120, 130, and 140 are executed sequentially again on this updated device behavior data stream to generate an updated device behavior event sequence set and an updated behavior temporal cause-effect structure diagram.

[0126] Step 312: Perform device-by-device and event-by-event temporal alignment processing on the updated device behavior event sequence set and the device behavior event sequence set used to generate the behavior temporal causal structure diagram before reconstruction, and identify the newly added behavior event fragment units and the hidden behavior event fragment units caused by the execution of the conflict resolution behavior instruction sequence.

[0127] The server compares the two sets of device behavior event sequences before and after the update. For single-device behavior event sequences with the same DevID, a dynamic time warping algorithm is used to align the two sequences on the timeline. After alignment, newly appearing behavior event fragments in the updated sequence are identified, i.e., their EvtSegIDs have no corresponding match in the pre-update sequence; and behavior event fragments that have disappeared in the updated sequence are identified, i.e., a certain EvtSegID in the pre-update sequence cannot be matched in the updated sequence. The newly added fragments and the disappeared fragments together reflect the changes in the cluster behavior trajectory caused by the resolution command.

[0128] Step 313: Align the node unit level of the behavior temporal causal structure diagram before reconstruction with the updated behavior temporal causal structure diagram, and extract the directed edge connection change part between the behavior event fragment units corresponding to the same device identifier field and the same behavior type field to generate a causal connection topology difference edge set.

[0129] The server considers nodes with the same NodeDev and NodeAct and similar temporal positions in the pre-reconstruction graph Gprev and the updated graph Gpost as corresponding node units. Based on this, it compares the outgoing and incoming edge sets of the corresponding node units in Gprev and Gpost. It extracts the newly added directed edges in Gpost and the directed edges that disappeared from Gpost, and aggregates these changed directed edges into a causal connection topological difference edge set, DiffEdgeSet.

[0130] Step 314: Map the degree of change of directed edges involving the conflict node to the root cause propagation link of the conflict in the causal connection topology difference edge set to the temporal causal structure perturbation intensity of the conflict resolution behavior instruction sequence on the root cause propagation link of the conflict. Use the temporal causal structure perturbation intensity to correct the edge attribute priority mark of the directed edges of resource use conflict relationship for the same behavior type field combination in the next preset monitoring period.

[0131] The server analyzes the number and type of changes to directed edges in the DiffEdgeSet between nodes involved in the original conflict root cause propagation path SeqRootCause. If a large number of temporally propagating conflict edges or resource conflict edges disappear in Gpost, it indicates a significant resolution effect and a high intensity of temporal causal structure perturbation; if conflict edges still exist or transform into other forms of conflict edges, it indicates a limited resolution effect. The server feeds back the calculated temporal causal structure perturbation intensity values ​​to the resolution strategy library to adjust the selection weights of the resolution strategies in step 1564, and also to correct the priority flag values ​​of the priority response edges in the conflict determination in step 213, so that the system's response strategy for similar conflicts is dynamically optimized according to the actual effect.

[0132] The foregoing has provided a detailed description of an electronic device conflict resolution method based on behavioral temporal causal inference, as provided in the embodiments of this application. The embodiments of this application illustrate the principle and implementation method using a specific scenario of data center computing nodes competing for shared storage resources. However, the above scenario is merely an example to aid in understanding the embodiments of this application and is not intended to limit the scope of application of the embodiments of this application. Those skilled in the art can make changes and modifications to the specific implementation methods and application scope based on the ideas of the embodiments of this application, and all such changes and modifications should be included within the protection scope of the embodiments of this application.

[0133] This application embodiment discretizes and aggregates device behavior data streams into behavior event fragment units. Based on the overlapping time periods of these fragment units' occupation of the same behavior-related resource field, a resource usage conflict relationship edge set is generated. Then, using the device behavior event sequence set as the temporal skeleton and the resource usage conflict relationship edge set as causal constraint edges, a behavior temporal causal structure graph is constructed, achieving a unified graph-structured representation of the temporal evolution of device cluster behavior and resource conflict relationships. Next, starting from the conflict node pairs connected by directed edges in the behavior temporal causal structure graph, the process traces backward to the original triggering behavior node that does not match any directed edge connection for resource usage conflict relationships. This tracing path is identified as the conflict root cause propagation link, enabling the resolution behavior instruction sequence to directly act on the causal source of the conflict rather than its manifestation, fundamentally improving the accuracy and efficiency of resolving resource conflicts in electronic device clusters.

[0134] Based on the above, those skilled in the art can combine conventional methods in the architecture design of existing distributed monitoring systems to achieve unified merging and global sorting of cross-node device behavior data streams. When the monitoring agent processes of each computing node continuously report device behavior recording units at millisecond granularity, if the system clocks between nodes are not strictly synchronized, the ascending order merging based on the behavior occurrence time field will result in timing deviations due to clock drift. To address this, a network time protocol daemon can be used to periodically calibrate the clocks of each computing node and the conflict resolution server, and a local server receiving timestamp can be added to each record as an auxiliary sorting field when the device behavior recording unit receives it. When the difference in the behavior occurrence time field is less than a preset clock error tolerance, the receiving timestamp arbitration order is used, thereby ensuring the global timing consistency of the device behavior data stream. Similarly, when splitting the device behavior data stream by the device identifier field, if the timestamp of a recording unit within a single device behavior recording substream is not strictly monotonically increasing due to jitter in agent process acquisition, the event time watermark mechanism in existing stream data processing technology can be used to perform tolerant sorting correction for out-of-order recording units.

[0135] Furthermore, those skilled in the art can combine existing interval overlap determination algorithms with time interval tree index structures to achieve efficient calculation of resource occupation time period overlap relationships between large-scale behavioral event segment units. In this application embodiment, the process of sorting all registration entries under the same resource identifier in the global resource occupation registration table and comparing overlapping time regions pairwise can lead to a quadratic increase in computational complexity when the number of resource identifiers is large and the list of registration entries corresponding to each resource identifier is long. To address this, after sorting the occupation time period sequence for each resource identifier, a scanline algorithm combined with a balanced binary search tree structure can be introduced to maintain the device ownership status of the current active occupation time period. When scanning to the start time of any entry, it is checked whether there are occupation records for other devices in the tree. If so, conflict relationship edges are generated in batches, thereby optimizing the overlap determination process to a linear logarithmic time complexity. Meanwhile, to address the potential problem of graph pattern matching state space explosion when detecting indirect conflict paths composed of temporally dependent edges and conflicting edges, we can combine reachability query and transitive closure pre-computation techniques from existing graph databases. First, we can perform strong connectivity component shrinking on the subgraph composed of temporally dependent edges, and then perform path enumeration on the shrunken directed acyclic graph to reduce the overhead of redundant path search.

[0136] Furthermore, those skilled in the art can combine the causal inference graph model pruning strategy and the Markov blanket boundary recognition method in the prior art to achieve reduction convergence of the conflict root cause propagation link tracing process. In the reverse tracing mechanism of this application embodiment, when the behavioral temporal causal structure graph has a large number of nodes and dense edge connections, if candidate predecessor nodes are screened along all incoming directed edges, the tracing path will diverge and fail to converge to the unique original triggering behavior node. To address this, a heuristic pruning function based on the duration field of the behavioral event fragment unit and the exclusivity strength of resource occupation can be introduced during the tracing process. Nodes in the candidate predecessor node set whose time interval with the current tracing starting node unit exceeds a preset causal association decay window are removed. Tracing is prioritized along directed edges whose conflict resource identifier in the edge attributes has an inclusion relationship with the current conflict link resource field, so that the tracing path converges according to the causal strength gradient. Furthermore, when generating resolution behavior instructions based on behavior type and resource fields, the token bucket rate limiting algorithm and weight dynamic adjustment mechanism in the existing resource scheduler can be combined to instantiate the abstract mapping rules in the resolution strategy library into quantitative control parameters for specific device identifier fields and resource identifiers, ensuring that the resolution instructions produce quantifiable constraint effects on the actual scheduling behavior of the target computing node.

[0137] Please see Figure 2The figure is a schematic diagram of the basic structure of an electronic device conflict resolution server 200 provided in an embodiment of this application. The electronic device conflict resolution server 200 includes: a processor 201; a storage device 202 on which a computer program 2020 is stored; and a network interface 203 for providing network communication functions. When the computer program 2020 is executed by the processor 201, the processor 201 implements any of the electronic device conflict resolution methods based on behavioral temporal causal inference.

[0138] Please see Figure 3 This application provides a functional block diagram of an electronic device conflict resolution device, which includes: The behavior data acquisition module is used to acquire the device behavior data stream generated by the electronic device cluster during a preset monitoring period; The behavior event discretization module is used to perform behavior event discretization processing on the device behavior data stream, and to aggregate device behavior record units with the same behavior type field and continuous temporal sequence under the same device identifier field into behavior event fragment units, and generate a set of device behavior event sequences grouped by the device identifier field. The conflict relationship generation module is used to extract the behavior-related resource field occupied by each behavior event segment unit in the device behavior event sequence set, and generate a cross-device resource usage conflict relationship edge set based on the overlapping time period of the behavior event segment units occupying the same behavior-related resource field between different device identifier fields. The temporal causal generation module is used to generate a behavior temporal causal structure diagram using the set of device behavior event sequences as the temporal skeleton and the set of resource usage conflict relationship edges as causal constraint edges. The conflict resolution processing module is used to start from the conflict node pairs with directed edges connecting resource usage conflict relationships in the behavior temporal causal structure graph, trace backward along the edge connections between nodes to the original triggering behavior node that does not match any directed edge connection for resource usage conflict relationships, determine the tracing path from the original triggering behavior node to the conflict node pair as the conflict root cause propagation link, and generate a conflict resolution behavior instruction sequence for the device identifier field associated with the conflict node pair based on the behavior type field and behavior associated resource field of each behavior event segment unit in the conflict root cause propagation link.

[0139] Based on the above, a readable storage medium is provided, on which a program or instructions are stored, and when the program or instructions are executed by a processor, the steps of the above method are implemented.

[0140] Furthermore, it should be noted that this application also provides a computer program product, which may include a computer program that can be stored in a computer-readable storage medium. The processor of the electronic device conflict resolution server reads the computer program from the computer-readable storage medium, and the processor can execute the computer program, causing the electronic device conflict resolution server to perform the aforementioned... Figure 1 The methods described in the corresponding embodiments are already known, and therefore will not be repeated here. Furthermore, the beneficial effects of using the same method will also not be repeated. For technical details not disclosed in the computer program product embodiments related to this application, please refer to the description of the method embodiments of this application.

[0141] It should be noted that the various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the systems or apparatus disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the descriptions are relatively simple, and relevant parts can be referred to the method section.

Claims

1. A method for resolving electronic device conflicts based on behavioral timing causal inference, the method comprising: The method includes: ​ Acquire device behavior data streams generated by the electronic device cluster during a preset monitoring period; The device behavior data stream is subjected to behavior event discretization processing. Device behavior record units with the same behavior type field and continuous time sequence under the same device identifier field are aggregated into behavior event fragment units to generate a set of device behavior event sequences grouped by the device identifier field. For each behavior event segment unit in the device behavior event sequence set, extract the behavior-related resource field it occupies, and generate a cross-device resource usage conflict relationship edge set based on the overlapping time period of the behavior event segment units occupying the same behavior-related resource field among different device identifier fields; Using the set of device behavior event sequences as the temporal skeleton and the set of resource usage conflict edges as causal constraint edges, a behavior temporal causal structure graph is generated. Starting from the conflict node pair with directed edge connection of resource usage conflict relationship in the behavior temporal causal structure graph, trace backward along the edge connection between nodes to the original trigger behavior node that does not match any directed edge connection of resource usage conflict relationship. The tracing path from the original trigger behavior node to the conflict node pair is determined as the conflict root cause propagation link. Based on the behavior type field and behavior associated resource field of each behavior event segment unit in the conflict root cause propagation link, generate a conflict resolution behavior instruction sequence for the device identifier field associated with the conflict node pair.

2. The method of claim 1, wherein, The process of discretizing the device behavior data stream involves aggregating device behavior record units with the same behavior type field and consecutive temporal sequence under the same device identifier field into behavior event fragment units, generating a set of device behavior event sequences grouped by the device identifier field, including: The device behavior data stream is split into multiple single device behavior record sub-streams according to different values ​​of the device identifier field. Each single device behavior record sub-stream corresponds uniquely to a value of the device identifier field. For each single device behavior record sub-stream, traverse the device behavior record units in the single device behavior record sub-stream one by one in the ascending direction of the behavior occurrence time field, and compare whether the behavior type field of the currently traversed device behavior record unit is the same as that of the previous adjacent device behavior record unit. If the behavior type field of the currently traversed device behavior record unit is the same as the behavior type field of the previous adjacent device behavior record unit, then the currently traversed device behavior record unit will be classified into the same behavior event fragment temporary storage container as the previous adjacent device behavior record unit. If the behavior type field of the currently traversed device behavior record unit is different from the behavior type field of the previous adjacent device behavior record unit, then the behavior event fragment temporary storage container where the previous adjacent device behavior record unit is located is closed, a behavior event fragment unit is generated, and a new behavior event fragment temporary storage container is created, with the currently traversed device behavior record unit as the first element of the new behavior event fragment temporary storage container. The device behavior event sequence set is generated by combining the event timing field of each closed generated behavior event fragment unit.

3. The method of claim 2, wherein, The process of combining the event timing field of each enclosed generated behavior event fragment unit to generate the device behavior event sequence set includes: For each closed generated behavior event fragment unit, the behavior occurrence time field of the first device behavior record unit in the behavior event fragment temporary storage container is extracted as the event start time field, the behavior occurrence time field of the last device behavior record unit in the behavior event fragment temporary storage container is extracted as the event end time field, and the time span between the event start time field and the event end time field is used as the event duration field. The behavior-related resource fields of all device behavior record units in the behavior event fragment temporary storage container are deduplicated and merged to generate a set of behavior-related resource fields occupied by the behavior event fragment unit during its duration. The event start time field, event end time field, event duration field, and behavior-related resource field set are combined and encapsulated with the device identifier field and behavior type field corresponding to the behavior event fragment unit to generate a behavior event fragment unit with a complete event attribute description. All behavioral event fragments under the same device identifier field are arranged in ascending order according to the event start time field to generate a single device behavioral event sequence; The single-device behavior event sequences corresponding to all device identifier fields are summarized to generate the device behavior event sequence set grouped by device identifier field.

4. The method according to claim 1 or 2, characterized in that, The step involves extracting the behavior-related resource field occupied by each behavior event segment unit in the device behavior event sequence set, and generating a cross-device resource usage conflict relationship edge set based on the overlapping time periods of the behavior event segment units occupying the same behavior-related resource field among different device identifier fields. This includes: Iterate through the single device behavior event sequence corresponding to each device identifier field in the device behavior event sequence set, perform resource field expansion processing on each behavior event fragment unit in the single device behavior event sequence, and expand the set of behavior-related resource fields carried by the behavior event fragment unit into multiple independent behavior-related resource field items; Establish a global resource occupancy registration table with the behavior-related resource field item as the index key. Each registration entry in the global resource occupancy registration table includes a resource occupancy device identifier field, a resource occupancy behavior event segment unit identifier, a resource occupancy start time field, and a resource occupancy end time field. For each behavior-related resource field item obtained from expansion, the device identifier field, behavior event fragment unit identifier, event start time field, and event end time field corresponding to the behavior-related resource field item are registered in the registration entry list under the corresponding index key in the global resource occupancy registration table. All entries under the associated resource field in the same row of the global resource occupancy registration table are sorted according to the order of the resource occupancy start time field, and an occupancy time sequence for the associated resource field in that row is generated. In the sequence of occupied time periods, two adjacent registration entries are selected in sequence, and it is compared whether there is a time overlap between the resource occupation end time field of the previous registration entry and the resource occupation start time field of the next registration entry. The time overlap is used to indicate that the resource occupation end time field of the previous registration entry is later than the resource occupation start time field of the next registration entry. If there is a time overlap between the previous and subsequent registration entries and the resource-occupying device identifier field in the previous registration entry is different from the resource-occupying device identifier field in the subsequent registration entry, then a directed edge for resource usage conflict relationship is generated, pointing from the behavior event fragment unit corresponding to the previous registration entry to the behavior event fragment unit corresponding to the subsequent registration entry. Extract the starting behavior event fragment unit identifier and the ending behavior event fragment unit identifier of the directed edge of the resource use conflict relationship, and attach the behavior associated resource field item that caused the conflict as the conflict resource identifier to the edge attribute of the directed edge of the resource use conflict relationship; All the directed edges of resource usage conflict relationships and their additional edge attributes that have been constructed are collected and organized to generate the cross-device resource usage conflict relationship edge set.

5. The method of claim 1, wherein, The step of generating a behavioral temporal causal structure graph using the set of device behavior event sequences as the temporal skeleton and the set of resource usage conflict edges as causal constraint edges includes: Each behavior event fragment unit in the device behavior event sequence set is transformed into an independent node unit in the initial causal structure graph, and a globally unique node identifier is assigned to each node unit; Map the device identifier field of each behavior event fragment unit to the device affiliation attribute of the node unit, map the behavior type field to the behavior category attribute of the node unit, map the event start time field to the timing start attribute of the node unit, and map the event end time field to the timing end attribute of the node unit. For node units corresponding to two temporally adjacent behavior event segments in the same single-device behavior event sequence, generate a temporally transitive directed edge from the temporally earlier node unit to the temporally later node unit, and mark the edge type attribute of the temporally transitive directed edge as a temporally dependent edge. Traverse each directed edge of the resource use conflict relationship set, and locate the corresponding start node unit and end node unit in the initial causal structure graph based on the start behavior event segment unit identifier and end behavior event segment unit identifier recorded in the directed edge of the resource use conflict relationship. Add a conflict relationship directed edge between the starting node unit and the ending node unit, corresponding to the resource usage conflict relationship directed edge. Mark the edge type attribute of the conflict relationship directed edge as a resource conflict edge, and write the conflict resource identifier attached to the resource usage conflict relationship directed edge into the edge attribute of the conflict relationship directed edge. Indirect conflict path detection is performed on the initial causal structure graph. Based on the detection results, directed edges for derived conflicts are added, and the behavior temporal causal structure graph is obtained by arranging the topology.

6. The method according to claim 5, characterized in that, The process of detecting indirect conflict paths in the initial causal structure graph, adding directed edges for derived conflicts based on the detection results, and reorganizing the topology to obtain the behavioral temporal causal structure graph includes: Detect whether there is an indirect conflict path in the initial causal structure graph that is connected by a time-transmission directed edge and also by a conflict relationship directed edge. If the starting node unit reaches the intermediate node unit through at least one time-transmission directed edge and the intermediate node unit is connected to the ending node unit through a conflict relationship directed edge, then add a derived conflict directed edge from the starting node unit to the ending node unit between the starting node unit and the ending node unit, and mark the edge type attribute of the derived conflict directed edge as a time-transmission conflict edge. Write the sequence of intermediate node units constituting the derivation conflict propagation process and the original edge type combination corresponding to each path segment into the edge attributes of the directed edge of the derivation conflict, so as to record the temporal propagation path of the conflict. The topology of all node units and their connected directed edges in the initial causal structure graph is sorted out, and the sorted set of node units and the set of directed edges are combined into the behavior temporal causal structure graph. Each node unit in the behavior temporal causal structure graph retains its device affiliation attribute, behavior category attribute, temporal start attribute, and temporal end attribute, and each directed edge retains its edge type attribute and corresponding edge attribute information.

7. The method according to claim 1 or 5, characterized in that, Starting from the conflicting node pairs with directed edges connecting resource usage conflicts in the behavior time-series causal structure graph, the process traces backward along the inter-node edges to the original triggering behavior node that does not match any directed edge connecting resource usage conflicts. The tracing path from the original triggering behavior node to the conflicting node pair is determined as the conflict root cause propagation link. Based on the behavior type field and behavior-associated resource field of each behavior event segment unit in the conflict root cause propagation link, a conflict resolution behavior instruction sequence is generated for the device identifier field associated with the conflicting node pair, including: In the behavioral temporal causal structure graph, identify all two node units directly connected by directed edges whose edge type attribute is resource conflict edge, and mark the two node units as a set of conflict node pairs. The conflict node pair includes a conflict source end node unit and a conflict target end node unit. For each pair of conflicting nodes, the conflict source node unit is used as the current tracing start node unit, and the conflict target node unit is used as the current tracing reference node unit. The conflict root cause propagation path temporary list is initialized, and the conflict source node unit and the conflict target node unit are added to the conflict root cause propagation path temporary list in sequence. Starting from the current tracing start node unit, retrieve all incoming directed edges with the current tracing start node unit as the endpoint of the directed edge in the behavioral temporal causal structure graph, and extract the start node units of all incoming directed edges as a set of candidate predecessor node units. In the candidate predecessor node unit set, predecessor node units that are connected to the current tracing starting node unit by a time-transfer directed edge, a resource conflict edge, or a time-transfer conflict edge are selected. The tracing direction is determined according to the priority of the edge type attribute, wherein the priority of the edge type attribute is determined in the order that resource conflict edges take precedence over time-transfer conflict edges over time-transfer directed edges. After determining the tracing direction, the selected predecessor node unit is taken as the new current tracing starting node unit, and the selected predecessor node unit is inserted into the starting position of the conflict root cause propagation path temporary list, and the current tracing starting node unit is updated to the new current tracing starting node unit. Based on the cyclic update process of the current tracing starting node unit, the original triggering behavior node unit is determined and a conflict root cause propagation link node sequence is generated. According to the conflict root cause propagation link node sequence, a resolution behavior instruction is generated and a conflict resolution behavior instruction sequence is determined.

8. The method according to claim 7, characterized in that, The cyclic update process based on the current tracing starting node unit determines the original triggering behavior node unit and generates a conflict root cause propagation link node sequence. Based on the conflict root cause propagation link node sequence, it generates resolution behavior instructions and determines a conflict resolution behavior instruction sequence, including: Repeat the steps of retrieving incoming directed edges, filtering predecessor node units, and updating the tracing start node unit until the current tracing start node unit has no resource conflict edge connection with the current tracing start node unit as the endpoint in the behavior temporal causal structure graph and no temporal propagation conflict edge connection with the current tracing start node unit as the endpoint, and determine the current tracing start node unit as the original trigger behavior node unit. Extract all node units from the conflict root cause propagation path temporary list, arranged sequentially from the original triggering behavior node unit to the conflict target end node unit, and generate the conflict root cause propagation link node sequence. Based on the behavioral event fragment unit mapped to each node unit in the conflict root cause propagation link node sequence, the behavior type field and behavior associated resource field of each behavioral event fragment unit are read sequentially; Based on the causal influence transmission relationship of the behavior type field of each node unit in the conflict root cause propagation link node sequence, a first resolution behavior instruction for the device identifier field associated with the conflict source node unit and a second resolution behavior instruction for the device identifier field associated with the conflict target node unit are generated, and the first resolution behavior instruction and the second resolution behavior instruction are combined into the conflict resolution behavior instruction sequence.

9. An electronic device conflict resolution server, characterized in that, include: A processor; a storage device having a computer program stored thereon; a network interface for providing network communication functions; wherein when the computer program is executed by the processor, the processor implements the electronic device conflict resolution method based on behavioral temporal causal inference as described in any one of claims 1-8.

10. A readable storage medium, characterized in that, The readable storage medium stores a program or instructions that, when executed by a processor, implement the electronic device conflict resolution method based on behavioral temporal causal inference as described in any one of claims 1-8.

Images