Bottleneck node determination method and apparatus, computer device, and storage medium

Abstract

The application discloses a bottleneck node determination method and device, computer equipment and a storage medium, relates to the technical field of computers, and can be applied to the financial field and the medical field. The method comprises the following steps: obtaining an operation event sequence of a target user in a target business process, and constructing a directed acyclic graph model according to the operation event sequence; determining a starting operation node with an in-degree of zero in the directed acyclic graph model; starting from the starting operation node, recursively calculating the maximum cumulative time consumption of each operation node and the path predecessor thereof; for each operation node, calculating the independent time consumption of the operation node, wherein the independent time consumption is the difference between the maximum cumulative time consumption of the operation node and the maximum cumulative time consumption of the path predecessor thereof; and determining a bottleneck node in the target business process according to the independent time consumption corresponding to each operation node. According to the scheme, the bottleneck node can be quickly and accurately located in a business scenario with high real-time requirements.

Description

Technical Field

[0001] This application relates to the field of computer technology and can be applied to the financial and medical fields. In particular, it relates to a method, apparatus, computer equipment, and storage medium for determining bottleneck nodes. Background Technology

[0002] In internet applications in fields such as finance and healthcare, to pinpoint the time-consuming bottlenecks affecting the overall efficiency of user operation processes, the user's operation steps and their flow relationships are usually abstracted into a directed acyclic graph model. The bottleneck node is determined by calculating the cumulative time of each path from the start operation to the end operation.

[0003] For example, in the financial loan application process, users need to perform identity verification, credit assessment, and credit limit approval in sequence, and the time taken for each step varies; in the online medical consultation process, users need to complete steps such as symptom input, doctor matching, consultation dialogue, prescription payment, etc., and page loading and interface response time directly affect the total process time.

[0004] However, when there are branches and convergences in such business processes, there may be multiple paths with different times from the starting point to the end point. Existing methods often need to enumerate all possible paths and calculate the total time for each one. The amount of computation increases exponentially with the number of nodes, resulting in low efficiency in locating bottleneck nodes in business scenarios with high real-time requirements. Summary of the Invention

[0005] This application provides a method, apparatus, computer device, and storage medium for determining bottleneck nodes, in order to solve the technical problem in the prior art that when there are branches and convergences in the business process, it is necessary to enumerate all possible paths and calculate the total time one by one, resulting in low efficiency in bottleneck node location.

[0006] In a first aspect, embodiments of this application provide a method for determining bottleneck nodes, including: Obtain the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, each operation event having an operation identifier and a trigger time; Based on the sequence of operation events, construct a directed acyclic graph model; In the directed acyclic graph model, determine the starting operation node with an in-degree of zero; Starting from the initial operation node, the maximum cumulative time consumption and its path predecessor for each operation node are calculated recursively. For each operation node, calculate the independent time consumption of that operation node, where the independent time consumption is the difference between the maximum cumulative time consumption of that operation node and the maximum cumulative time consumption of its predecessor along the path. Based on the independent time consumption corresponding to each operation node, the bottleneck node in the target business process is determined.

[0007] Secondly, embodiments of this application provide a bottleneck node determination apparatus, comprising: The acquisition module is used to acquire the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, each operation event having an operation identifier and a trigger time; The construction module is used to construct a directed acyclic graph model based on the sequence of operation events; The first determining module is used to determine the starting operation node with an in-degree of zero in the directed acyclic graph model. The first calculation module is used to recursively calculate the maximum cumulative time consumption and its path predecessor for each operation node, starting from the initial operation node. The second calculation module is used to calculate the independent time consumption of each operation node, wherein the independent time consumption is the difference between the maximum cumulative time consumption of the operation node and the maximum cumulative time consumption of its path predecessor. The second determining module is used to determine the bottleneck node in the target business process based on the independent time consumption corresponding to each of the operation nodes.

[0008] Thirdly, embodiments of this application provide a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the above-mentioned bottleneck node determination method.

[0009] Fourthly, embodiments of this application provide a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps of the above-described bottleneck node determination method.

[0010] The aforementioned bottleneck node determination method, device, computer equipment, and storage medium construct a directed acyclic graph model from the sequence of operation events. Starting from the initial operation node with an in-degree of zero, the maximum cumulative time consumption and its path predecessor of each operation node are recursively calculated along the topological order. This allows for the calculation of the longest path consumption of each operation node in complex business processes with branches and convergences without enumerating all possible paths from the starting point to the end point. Only one topological traversal is needed to complete the calculation of the longest path consumption of each operation node, and the computational load increases linearly with the number of nodes. Based on this, the maximum cumulative time consumption of each operation node is subtracted from the maximum cumulative time consumption of its path predecessor. The difference is the independent time consumption of that operation node relative to its longest path predecessor, effectively separating the upstream propagation time in the time difference between adjacent operations. Finally, the bottleneck is determined based on the independent time consumption of each operation node, enabling the rapid and accurate location of bottleneck nodes in business scenarios with high real-time requirements. Attached Figure Description

[0011] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the description of the embodiments of this application will be briefly introduced below. Obviously, the 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.

[0012] Figure 1 This is a schematic diagram of an application environment for a bottleneck node determination method in one embodiment of this application; Figure 2 This is a flowchart illustrating a method for determining bottleneck nodes in one embodiment of this application; Figure 3 This is a schematic diagram of a bottleneck node determination device in one embodiment of this application; Figure 4 This is a schematic diagram of the structure of a computer device according to one embodiment of this application. Detailed Implementation

[0013] 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, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0014] The bottleneck node determination method provided in this application embodiment can be applied to, for example... Figure 1 The application environment shown. Specifically, this bottleneck node determination method is applied in a bottleneck node determination system, which includes, for example,... Figure 1 The diagram illustrates a client and server that communicate over a network to implement the bottleneck node identification method. The client, also known as the user terminal, refers to the program that provides local services to the client, corresponding to the server. Clients can include, but are not limited to, various personal computers, laptops, smartphones, and tablets. The server can be a standalone server or a server cluster consisting of multiple servers.

[0015] Firstly, such as Figure 2 As shown, this application embodiment provides a method for determining bottleneck nodes, which is applied to... Figure 1 Taking the server in the example, the following steps are included: S101: Obtain the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, each operation event having an operation identifier and a trigger time.

[0016] As an example, a target business process refers to a set of operations that a target user needs to perform in an application system to complete a specific business function. For example, in an online consultation, this could be the complete process from symptom input to prescription payment, or in a financial service, the approval process from loan application to loan disbursement confirmation. A target user is a user who completes the target business process, such as a patient seeking medical treatment in an online consultation, or an individual applying for a loan in a financial service. An operation event is an event record corresponding to a single action performed by a target user on the application interface, such as clicking the department selection button or submitting a payment request in an online consultation, or clicking the loan application submission button or undergoing facial recognition verification in a financial service. An operation identifier is an identifier used to uniquely distinguish different operation types, such as "symptom input," "department selection," "loan application completion," or "upload credit information." A trigger time is the system timestamp when the operation is triggered, such as the current system time recorded by the server when the user clicks the "confirm consultation order" button on the application interface. An operation event sequence refers to an ordered set of multiple operation events belonging to the same target business process, arranged in chronological order of their triggering time. For example, in online consultation, the sequence arranged in chronological order is "symptom input → select department → select doctor → fill in the description of the condition → confirm consultation order → online payment → consultation completed", or in financial business, the sequence arranged in chronological order is "fill in loan application → upload credit materials → facial recognition verification → risk control system review → credit limit approval → electronic contract signing → loan disbursement confirmation".

[0017] S102: Construct a directed acyclic graph model based on the sequence of operation events.

[0018] As an example, a directed acyclic graph (DAG) model refers to a directed graph data structure where the operation nodes corresponding to operation events are nodes, the temporal flow relationships between operation events are directed edges, and there are no loops formed by connecting the beginning and end of directed edges. In this step, operation events in the operation event sequence can be mapped to operation nodes, the temporal flow relationships between operation events can be mapped to directed edges, and each directed edge can be assigned a corresponding edge weight to construct a DAG model consisting of operation nodes, directed edges, and edge weights. For example, in an online consultation business, "symptom input," "select department," "select doctor," "fill in the description of the condition," "confirm consultation order," "online payment," and "consultation completed" are mapped to operation nodes respectively. A directed edge is established between "symptom input" and "select department," with an edge weight equal to the trigger time difference of 2 seconds between the two. A directed edge is established between "select department" and "select doctor," with an edge weight equal to the trigger time difference of 3 seconds between the two, and so on, ultimately constructing a DAG model for the online consultation business process.

[0019] S103: In a directed acyclic graph model, determine the starting operation node with an in-degree of zero.

[0020] As an example, in-degree refers to the number of directed edges pointing to a given operation node in a directed acyclic graph (DAG) model. An operation node with an in-degree of zero means that no directed edges point to that operation node, i.e., that operation node has no predecessor operation node in the DAG model. The starting operation node is an operation node with an in-degree of zero, corresponding to the first operation event performed by the target user in the target business process. For example, in the online consultation business process, the "symptom input" operation node has an in-degree of zero, which is the starting operation node.

[0021] S104: Starting from the initial operation node, recursively calculate the maximum cumulative time consumption and its path predecessor for each operation node.

[0022] As an example, the maximum cumulative time is the maximum sum of the edge weights across all possible paths from the starting node to a given node. The path predecessor is the predecessor node that enabled the current node to achieve the maximum cumulative time. Recursive calculation refers to calculating the maximum cumulative time of the current node according to the topological order of the nodes, sequentially using the maximum cumulative time of the predecessor nodes and their corresponding edge weights. For example, in an online consultation, starting from the starting node "Symptom Input," its maximum cumulative time is 0ms; the maximum cumulative time for "Select Department" is 0+2=2s, with "Symptom Input" as the path predecessor; the maximum cumulative time for "Select Doctor" is 2+3=5s, with "Select Department" as the path predecessor, and so on, until the "Consultation Completed" node.

[0023] This step recursively calculates the maximum cumulative time and its predecessors for each operation node, starting from the initial operation node. It quantifies the longest time from the initial operation event to each operation event and records the predecessor operation node that achieves this longest time. Because a recursive approach is used, each operation node only needs to be calculated once after all its predecessor operation nodes have been calculated. Therefore, the time complexity of the entire calculation process is linearly related to the number of operation nodes, improving the computational efficiency of bottleneck location.

[0024] S105: For each operation node, calculate the independent time consumption of that operation node. The independent time consumption is the difference between the maximum cumulative time consumption of that operation node and the maximum cumulative time consumption of its predecessor.

[0025] As an example, independent latency refers to the independent contribution of each operation node to the overall process latency. After obtaining the maximum cumulative latency and predecessor of each operation node, the server calculates the difference between the maximum cumulative latency of the operation node and the maximum cumulative latency of its predecessor to obtain the independent latency of that operation node. For example, in an online consultation service, the maximum cumulative latency of "selecting a doctor" is 5 seconds, and the maximum cumulative latency of its predecessor "selecting a department" is 2 seconds. Therefore, the independent latency of "selecting a doctor" is 5 - 2 = 3 seconds. Independent latency reflects the latency introduced by the operation node itself after removing the cumulative impact of the preceding process.

[0026] This step quantifies the independent contribution of each operation node to the overall time consumption of the target business process by calculating the independent time consumption of each operation node. Independent time consumption eliminates the cumulative delay impact of preceding operation steps, allowing bottleneck node identification to focus on the delay contribution of each operation node itself. This effectively avoids incorrectly attributing the delay of preceding nodes to subsequent nodes, thereby improving the accuracy of bottleneck location.

[0027] S106: Based on the independent time consumption of each operation node, determine the bottleneck node in the target business process.

[0028] As an example, a bottleneck node refers to the operation node in the target business process that has the greatest impact on the overall process time. The server identifies the operation node with the longest independent time by comparing the individual times of each operation node. For example, in an online consultation business, the independent times of each operation node are: symptom input (0s), department selection (2s), doctor selection (3s), description of illness (3s), confirmation of consultation order (5s), online payment (3s), and consultation completion (3s). The "confirmation of consultation order" has the longest independent time (5s), therefore, it is identified as the bottleneck node.

[0029] This step identifies bottleneck nodes by determining the independent time consumption of each operation node, pinpointing the operation steps in the target business process that cause the greatest delay. This provides a clear target for subsequent optimization of these operation steps, ensuring that optimization resources are precisely focused on the links that contribute the most to improving the overall process time consumption.

[0030] In summary, the technical solution provided in this application constructs a directed acyclic graph model of the sequence of operation events. Starting from the initial operation node with an in-degree of zero, it recursively calculates the maximum cumulative time consumption and its predecessor along the topological order for each operation node. This allows for the calculation of the longest path time of each operation node in complex business processes with branches and convergences without enumerating all possible paths from the starting point to the end point. Only one topological traversal is needed to complete the calculation of the longest path time of each operation node, and the computational workload increases linearly with the number of nodes. Based on this, the maximum cumulative time consumption of each operation node is subtracted from the maximum cumulative time consumption of its predecessor, and the difference is the independent time consumption of that operation node relative to its longest path predecessor. This effectively separates the upstream propagation time consumption in the time difference between adjacent operations. Finally, bottlenecks are determined based on the independent time consumption of each operation node, enabling the rapid and accurate location of bottleneck nodes in business scenarios with high real-time requirements.

[0031] In one embodiment, obtaining the sequence of operation events of the target user in the target business process includes the following steps: S111: Generate operation event records based on the operation behavior triggered by the target user on the application interface. Each operation event record includes the operation identifier and the trigger time. S112: Obtain the start operation identifier and end operation identifier corresponding to the target business process; S113: Filter out operation event records from the generated operation event records that have operation identifiers belonging to the target business process and whose trigger times are between the trigger times corresponding to the start operation identifier and the trigger times corresponding to the end operation identifier; S114: Sort the selected operation event records in ascending order of trigger time to obtain the operation event sequence.

[0032] As an example, an application interface refers to the user interface through which a user interacts with the system, such as a webpage, mobile application interface, or desktop application interface. The start and end operation identifiers corresponding to the target business process are predefined and used to define the start and end range of the target business process within the sequence of operation events.

[0033] The operation event corresponding to the start operation identifier marks the beginning of the target business process, while the operation event corresponding to the end operation identifier marks the end of the target business process. The server performs dual filtering on all operation event records, using the trigger time corresponding to the start operation identifier as the lower bound of the time window and the trigger time corresponding to the end operation identifier as the upper bound. The first filtering is operation identifier filtering, which retains only operation event records whose operation identifiers belong to the target business process, excluding event records generated by other operations performed by the target user outside the target business process, such as excluding user actions like closing advertisements or browsing announcements on the application interface. The second filtering is trigger time window filtering, which, based on the operation identifier filtering results, retains only operation event records whose trigger times fall within the aforementioned time window, excluding operation event records triggered by the target user before entering or after completing the target business process.

[0034] The reason for using the above dual filtering is that relying solely on operation identifier filtering may mix up the operation event records generated by the target user executing the target business process multiple times at different times, making it impossible to distinguish the complete sequence of operation events for a specific execution; relying solely on trigger time window filtering may mistakenly filter out operation event records that belong to other business processes but whose trigger time happens to fall within that time window.

[0035] By using a dual filtering method based on operation identifiers and trigger time windows, it is ensured that the selected operation event records not only belong to the target business process but also completely correspond to all operation events generated by the target user during a continuous business execution, thereby guaranteeing the process integrity and temporal consistency of the operation event sequence. The selected operation event records are then arranged in ascending order according to their trigger times to form a complete operation event sequence.

[0036] For example, in the field of financial transaction monitoring, a securities trading platform conducts bottleneck analysis on traders' trading operation processes. The target business process is the securities trading process, with the starting operation identifier being "trading login" and the ending operation identifier being "trade confirmation." Traders' actions on the trading terminal are monitored in real time and operation event records are generated. Since a trader may execute the securities trading process multiple times within a workday, each login and trade confirmation constitutes an independent trading session. Therefore, filtering by operation identifier alone cannot distinguish the operation event records of different trading sessions. The server uses a first-level filter to select operation event records whose operation identifiers belong to the securities trading process, such as filtering operation event records corresponding to operation identifiers like "trading login," "market data query," "order placement," and "trade confirmation," while excluding operations such as "browsing announcements" and "changing password," which do not belong to the securities trading process. Then, through a second layer of filtering, the operation event records whose trigger time falls within the time window are filtered out, with the trigger time of a certain "trading login" as the lower bound and the trigger time of the corresponding "trade confirmation" as the upper bound. This extracts the operation event records of a single complete trading session from all operation event records throughout the day, and then sorts them in ascending order by trigger time to obtain the operation event sequence.

[0037] This embodiment uses a dual filtering mechanism—operation identifier filtering and trigger time window filtering—to accurately extract the sequence of operation events corresponding to a single complete execution of the target business process from the full operation event record. This not only eliminates interference from irrelevant operation events and different execution batches but also ensures the process integrity and temporal consistency of the operation event sequence, providing high-quality data input for the subsequent construction of a directed acyclic graph model.

[0038] In one embodiment, the construction of a directed acyclic graph model based on the sequence of operation events includes the following steps: S121: Create an operation node for each operation event in the operation event sequence, and use the operation identifier of the operation event as the identifier of the created operation node; S122: Sequentially obtain every two adjacent operation events in the operation event sequence arranged in ascending order of trigger time, determine the operation event with the earlier trigger time as the first operation event, and determine the operation event with the later trigger time as the second operation event; S123: Establish a directed edge between the operation node corresponding to the first operation event and the operation node corresponding to the second operation event. The direction of the directed edge is from the operation node corresponding to the first operation event to the operation node corresponding to the second operation event. S124: Use the time difference between the triggering of the first operation event and the second operation event as the edge weight of the established directed edge; S125: Perform loop detection on the directed graph obtained after establishing directed edges; S126: If a cycle exists, delete the directed edge with the smallest weight from all directed edges that form the cycle, and perform cycle detection again on the directed graph after deleting the directed edge with the smallest weight, until the detection result indicates that there is no cycle in the graph, and take the directed graph with no cycle in the graph as the directed acyclic graph model. S127: If there are no loops, then the directed graph is determined to be a directed acyclic graph model.

[0039] As an example, the server first creates an operation node for each operation event in the operation event sequence. The identifier of the operation node is the operation identifier of that operation event, thus establishing a one-to-one correspondence between operation events and graph nodes. Each operation node represents an operation step in the target business process. Then, the server traverses every two adjacent operation events in the operation event sequence in ascending order of trigger time, designating the operation event with the earlier trigger time as the first operation event and the operation event with the later trigger time as the second operation event. A directed edge is established between the operation nodes corresponding to the first and second operation events, with the direction of the directed edge pointing from the operation node corresponding to the first operation event to the operation node corresponding to the second operation event. This direction represents the conversion flow of the target user from the first operation step to the second operation step. The weight of the directed edge is the difference between the trigger times of the first and second operation events, i.e., the trigger time of the second operation event minus the trigger time of the first operation event. This difference represents the actual time consumed by the target user from completing the first operation step to completing the second operation step.

[0040] After establishing all directed edges, the server performs cycle detection on the resulting directed graph. Cycle detection refers to determining whether there exists a closed loop in the directed graph that starts from an operation node, traverses several directed edges, and returns to that operation node. If a loop is detected, it indicates a cyclic dependency between operation events in the sequence of operation events. For example, if the target user repeatedly jumps between two operation steps, a closed loop appears in the directed graph, which does not meet the structural requirements of a directed acyclic graph. In this case, the server identifies the directed edge with the smallest edge weight from all the directed edges forming the loop, representing the shortest operation transition in the loop. This directed edge is then removed from the directed graph, and cycle detection is performed again on the deleted directed graph. This detection and removal process is repeated until the detection result indicates that there are no loops in the graph. The directed graph without loops at this point is then considered a directed acyclic graph model. If no loops are found in the initial detection, the directed graph obtained after establishing the directed edges is directly identified as a directed acyclic graph model.

[0041] For example, in a credit approval scenario in the financial sector, the sequence of operation events is as follows: filling out a loan application (T1=0s), uploading credit information (T2=3s), facial recognition verification (T3=8s), risk control system review (T4=15s), credit limit approval (T5=25s), electronic contract signing (T6=32s), and loan disbursement confirmation (T7=38s). The server creates an operation node for each operation event, using the operation identifier of each event as the identifier for the corresponding operation node. The server identifies "filling out a loan application" and "uploading credit information" as adjacent operation events, establishing a directed edge between the "filling out a loan application" operation node and the "uploading credit information" operation node, with a weight of 3s. The server also establishes a directed edge between "uploading credit information" and "facial recognition verification," with a weight of 5s. Following this pattern, the server establishes directed edges between every two adjacent operation nodes, with edge weights of 3s, 5s, 7s, 10s, 7s, and 6s respectively. After loop detection confirms no loops, the server determines the resulting directed graph to be a directed acyclic graph model.

[0042] For example, in an online medical consultation scenario, the sequence of operation events is as follows: symptom input (T1=0s), department selection (T2=2s), doctor selection (T3=5s), description of symptoms (T4=8s), confirmation of consultation order (T5=13s), online payment (T6=16s), consultation completion (T7=19s). The server creates an operation node for each operation event, using the operation identifier of each operation event as the identifier of the corresponding operation node. The server establishes directed edges between every two adjacent operation nodes, with edge weights of 2s, 3s, 3s, 5s, 3s, and 3s respectively. After loop detection confirms no loops, the server determines the resulting directed graph to be a directed acyclic graph model.

[0043] This embodiment ensures that the generated directed acyclic graph model accurately reflects the temporal transformation relationship and actual time consumption between operation events, while also meeting the structural requirements of a directed acyclic graph, by automatically creating operation nodes, establishing directed edges between adjacent operation events and calculating the trigger time difference as the edge weight, and executing a loop detection and elimination mechanism. This provides a reliable graph data structure foundation for subsequent recursive calculations based on topological sorting.

[0044] In one embodiment, after constructing the directed acyclic graph model, the following steps are further included: S128: For each operation node in the directed acyclic graph model, generate a predecessor association list for that operation node. Each entry in the predecessor association list contains the identifier of a predecessor operation node and the edge weight of the directed edge from the predecessor operation node to the operation node. S129: Using the identifier of the operation node as the key and the predecessor association list as the value, store the key-value pair into the Redis RMap data structure.

[0045] As an example, a predecessor association list refers to a structured data set of all predecessor operation nodes and their corresponding edge weights for an operation node. Each entry consists of the identifier of the predecessor operation node and the weight of the directed edge from that predecessor operation node to the current operation node. Redis is an in-memory key-value store database. RMap is a data structure in Redis used to store key-value pair mappings. It can store data in the form of key-value pairs, where the key is the identifier of the operation node and the value is the predecessor association list of that operation node.

[0046] In this embodiment, the server traverses each operation node in the directed acyclic graph model. For each operation node, it determines the starting node of all directed edges pointing to that operation node as its predecessor operation node and obtains the edge weights of the directed edges from each predecessor operation node to that operation node. The server groups the identifier of each predecessor operation node and its corresponding edge weight into an entry, and summarizes all entries into a predecessor association list for that operation node. Then, the server stores the key-value pair in a Redis RMap data structure, using the identifier of the operation node as the key and the predecessor association list as the value. Through the RMap storage method, during subsequent recursive calculations, all predecessor operation nodes and their corresponding edge weights of the operation node can be quickly retrieved from the RMap based on the identifier of the operation node, without having to traverse the directed edges in the directed acyclic graph model again.

[0047] For example, in a credit approval scenario in the financial sector, the "Risk Control System Review" operation node in a directed acyclic graph model has a predecessor operation node "Face Recognition Verification." The directed edge from this predecessor operation node to the "Risk Control System Review" operation node has a weight of 7s. The server generates a predecessor association list for the "Risk Control System Review" operation node, which contains an entry: {Predecessor operation node identifier: "Face Recognition Verification", Edge weight: 7s}. The server stores the key-value pair, using "Risk Control System Review" as the key and this predecessor association list as the value, in a Redis RMap data structure. Subsequently, when recursively calculating the maximum cumulative time of the "Risk Control System Review" operation node, the server can directly obtain the identifier of "Face Recognition Verification" and the edge weight 7s through RMap, quickly completing the calculation.

[0048] For example, in an online consultation scenario in the medical field, the "Select Doctor" operation node in a directed acyclic graph model has a predecessor operation node "Select Department," and the weight of the directed edge pointing to the "Select Doctor" operation node is 3s. The server generates a predecessor association list for the "Select Doctor" operation node, which contains an entry: {predecessor operation node identifier: "Select Department", edge weight: 3s}. The server stores the key-value pair, using "Select Doctor" as the key and the predecessor association list as the value, in a Redis RMap data structure. Subsequent recursive calculations can directly read from the RMap.

[0049] This embodiment generates a predecessor association list for each operation node, structurally organizing all predecessor operation nodes and their corresponding directed edge weights for each operation node, and persistently storing them using Redis's RMap data structure. This allows for quick querying and retrieval of all predecessor information of the current operation node during subsequent recursive calculations, using the operation node identifier as an index. This avoids retracing the directed edges in the directed acyclic graph model for each calculation, thus improving access efficiency and computational performance in large-scale directed acyclic graph data scenarios.

[0050] In one embodiment, that is, in a directed acyclic graph model, determining the starting operation node with an in-degree of zero includes the following steps: S131: Set the initial in-degree count to zero for each operation node in the directed acyclic graph model; S132: Traverse each directed edge in the directed acyclic graph model, and for the endpoint node of each directed edge, increment its in-degree count by 1; S133: Determine the operation node with an in-degree count of zero as the starting operation node.

[0051] As an example, the in-degree count refers to the number of directed edges pointing to a given node in a directed acyclic graph (DAG) model. In other words, it represents how many predecessor nodes that node has, each linked to the current node by a directed edge. A zero in-degree count indicates that no directed edges point to the current node, meaning that the current node has no predecessor nodes in the DAG model.

[0052] In this embodiment, the server first sets the initial in-degree count to zero for each operation node in the directed acyclic graph (DAG) model, that is, it creates an in-degree counter for each operation node and initializes its value to zero. Then, the server traverses all directed edges in the DAG model. Each directed edge has a starting operation node and an ending operation node, and the direction of the directed edge is from the starting operation node to the ending operation node, indicating that the target user flows from the operation step corresponding to the starting operation node to the operation step corresponding to the ending operation node. For the ending operation node of each directed edge, the server increments the in-degree count of the ending operation node by 1, indicating that the ending operation node has a predecessor dependency from the starting operation node. Since a directed edge may be pointed to by multiple different directed edges, its in-degree count will be accumulated by the number of all directed edges pointing to it. After traversing all directed edges, an operation node with an in-degree count of zero indicates that no directed edge points to the operation node, that is, the operation node has no predecessor operation node, and the server determines the operation node with an in-degree count of zero as the starting operation node. In the user operation sequence, the starting operation node corresponds to the first operation step executed by the target user in the target business process, and is the starting point of the entire business process.

[0053] For example, in the field of financial transaction monitoring, the directed acyclic graph model of the securities trading process includes a transaction login node, a market data query node, an order placement node, and a trade confirmation node. The server initially sets the in-degree count of each of these four nodes to zero. Then, it traverses the directed edges: the directed edge from the transaction login node to the market data query node increments the in-degree count of the market data query node by 1; the directed edge from the market data query node to the order placement node increments the in-degree count of the order placement node by 1; and the directed edge from the order placement node to the trade confirmation node increments the in-degree count of the trade confirmation node by 1. After traversal, the in-degree count of the transaction login node is zero, the in-degree count of the market data query node is 1, the in-degree count of the order placement node is 1, and the in-degree count of the trade confirmation node is 1. The server then identifies the transaction login node with an in-degree count of zero as the starting operation node.

[0054] This embodiment accurately identifies the starting operation node in a directed acyclic graph model that has no predecessor operation node by setting an in-degree count for each operation node and traversing the directed edges to accumulate the count. This starting operation node serves as the first operation step in the target business process, providing a clear starting point for subsequent recursive calculations. This ensures that the longest path calculation starts from the correct beginning of the process, effectively avoiding calculation deviations along the entire path due to incorrect selection of the starting node.

[0055] In one embodiment, starting from the initial operation node, the maximum cumulative time of each operation node and its path predecessor are calculated recursively, including the following steps: S141: Set the maximum cumulative time of the starting operation node to zero, and set the predecessor of the path of the starting operation node to empty; S142: Perform topological sorting on the operation nodes in the directed acyclic graph model to obtain the node processing sequence; S143: Following the order of the node processing sequence, each operation node is taken out as the current operation node in turn, until all operation nodes in the node processing sequence have been taken out; For each current operation node, execute: S143A: Get all predecessor operation nodes of the current operation node, and the edge weights of the directed edges from each predecessor operation node to the current operation node. S143B: For each predecessor operation node, calculate the sum of the maximum cumulative time of the predecessor operation node and the corresponding edge weight, and use it as the cumulative time of the candidate path. S143C: Determine the maximum cumulative time among the candidate paths as the maximum cumulative time of the current operation node, and record the predecessor operation node that obtains the maximum value as the path predecessor of the current operation node.

[0056] As an example, the mathematical expression of the above recursive calculation process can be: in, Indicates the current operating node Maximum cumulative time, Indicates the current operating node The set of all predecessor operation nodes, This refers to any of the predecessor nodes of the current operating node. This represents the maximum cumulative time consumed by the preceding operation node. Let be the edge weight of the directed edge from the predecessor node to the current node. Where is the maximum cumulative time consumed by the starting node. It is set to an initial value of zero, and its path predecessor is set to empty.

[0057] Topological sorting refers to arranging all operation nodes in a directed acyclic graph (DAG) model into a linear sequence, such that for each directed edge in the graph, the starting operation node of that edge precedes the ending operation node in the sequence. The server first sets the maximum cumulative time of the starting operation node to zero and sets its path predecessor to null. A null path predecessor indicates that the starting operation node has no predecessor and is the first operation step executed in the target business process. Then, the server performs topological sorting on all operation nodes in the DAG model, obtaining a node processing sequence. The node processing sequence is an ordered list, where the order of operation nodes ensures that all predecessor operation nodes of each operation node appear before that operation node. The server processes each operation node sequentially according to the node processing sequence until all operation nodes in the sequence have been processed.

[0058] For each current operation node, the server first obtains all its predecessor operation nodes. A predecessor operation node is an operation node that is directly connected to the current operation node via a directed edge. The server also obtains the edge weight of each directed edge, which is the time value associated with the directed edge from each predecessor operation node to the current operation node. Then, for each predecessor operation node, the server obtains the maximum accumulated time calculated for that predecessor operation node, adds this maximum accumulated time to the edge weight from that predecessor operation node to the current operation node, and obtains a candidate path accumulated time. The candidate path accumulated time represents the total accumulated time of the path from the starting operation node, through the predecessor operation node, to the current operation node. When the current operation node has multiple predecessor operation nodes, the server will calculate multiple candidate path accumulated times, each candidate path accumulated time corresponding to a different arrival path. The server determines the maximum accumulated time of the candidate path accumulated times as the maximum accumulated time of the current operation node, and records the operation identifier of the predecessor operation node that obtained the maximum value as the path predecessor of the current operation node. The path predecessor identifies which path to reach the current operation node will yield the longest cumulative time.

[0059] For example, in a credit approval scenario in the financial sector, the server sets the dp[Fill in loan application] of the initial operation node "Fill in loan application" to zero, and the predecessor of the path to be empty. Topologically sorting all operation nodes yields the following node processing sequence: Fill in loan application → Upload credit information → Facial recognition verification → Risk control system review → Credit limit approval → Electronic contract signing → Loan disbursement confirmation. Processing is done according to the node processing sequence: The predecessor of the "Upload credit information" operation node is "Fill in loan application," and the cumulative time for the candidate path is dp[Fill in loan application] + weight(Fill in loan application, Upload credit information) = 0 + 3 = 3 seconds. dp[Upload credit information] is determined to be 3 seconds, and the predecessor of the path is "Fill in loan application." Similarly, the predecessor of the "Facial recognition verification" operation node is "Upload credit information," and the cumulative time for the candidate path is dp[Upload credit information] + weight(Upload credit information, Facial recognition verification) = 3 + 5 = 8 seconds. dp[Facial recognition verification] is determined to be 8 seconds, and the predecessor of the path is "Upload credit information." The process is repeated sequentially until the "Loan Confirmation" step is reached.

[0060] For example, in an online medical consultation scenario, the server sets the dp[symptom input] of the initial operation node "symptom input" to zero and the predecessor of the path to empty. After topological sorting, the node processing sequence is: symptom input → select department → select doctor → fill in the description of the condition → confirm the consultation order → online payment → consultation complete. Processing is done according to the node processing sequence: the predecessor of the "select department" operation node is "symptom input", the cumulative time for the candidate path is dp[symptom input] + weight(symptom input, select department) = 0 + 2 = 2s, dp[select department] is determined to be 2s, and the predecessor of the path is "symptom input"; the predecessor of the "select doctor" operation node is "select department", the cumulative time for the candidate path is dp[select department] + weight(select department, select doctor) = 2 + 3 = 5s, dp[select doctor] is determined to be 5s, and the predecessor of the path is "select department". This process is repeated until the "consultation complete" operation node.

[0061] In the field of financial transaction monitoring, the directed acyclic graph model of the securities trading process can also include transaction login nodes, market data query nodes, order placement nodes, and trade confirmation nodes. If a trader places an order directly after querying market data, or performs technical analysis first, then the order placement node has multiple predecessor operation nodes. The server iterates through all predecessor operation nodes of the order placement node, calculates the cumulative time of each candidate path, takes the maximum value as the maximum cumulative time of the order placement node, and records the corresponding path predecessor. Through the above recursive calculation, the longest time-consuming path from transaction login to trade confirmation and the path predecessor relationships of each node can be obtained.

[0062] This embodiment ensures that each operation node is processed only after all its predecessor operation nodes have been computed through topological sorting. It uses recursive dynamic programming equations to solve for the longest path from the starting operation node to each operation node in the directed acyclic graph model. The computation of each operation node depends only on the maximum cumulative time and corresponding edge weights already calculated for its predecessor operation nodes. Each operation node only needs to be computed once; therefore, the maximum cumulative time of all operation nodes in the entire directed acyclic graph model can be calculated in a single traversal. The time complexity is linearly related to the number of operation nodes, significantly improving the computational efficiency of bottleneck localization. This approach is suitable for real-time analysis scenarios involving large-scale operation event sequences.

[0063] In one embodiment, identifying bottleneck nodes in the target business process based on the independent time consumption of each operation node includes the following steps: S161: Obtain the independent time consumption of each operation node; S162: Determine the maximum independent time from all independent times; S163: Identify operation nodes whose independent execution time equals the maximum independent execution time as candidate bottleneck nodes; S164: If there is only one candidate bottleneck node, then that candidate bottleneck node is determined as the bottleneck node. S165: If there are multiple candidate bottleneck nodes, select the candidate bottleneck node with the minimum maximum cumulative time from among the multiple candidate bottleneck nodes as the bottleneck node.

[0064] As an example, after obtaining the independent execution time of all operation nodes, the server determines the maximum independent execution time by comparing the individual execution times. The operation node with an independent execution time equal to this maximum independent execution time is identified as a candidate bottleneck node. When there is only one candidate bottleneck node, the server directly identifies it as the bottleneck node, prioritizing it as the operation step to be optimized in the target business process. When there are multiple candidate bottleneck nodes, it indicates that multiple operation nodes have the same independent execution time, all of which are the maximum values. In this case, the server needs to further filter from the multiple candidate bottleneck nodes. The server obtains the maximum cumulative execution time of each candidate bottleneck node, compares the maximum cumulative execution times of each candidate bottleneck node, and selects the candidate bottleneck node with the smallest maximum cumulative execution time as the bottleneck node. The reason for selecting the candidate bottleneck node with the smaller maximum cumulative execution time is that the maximum cumulative execution time reflects the total time of the preceding path from the starting operation node to this operation node. The candidate bottleneck node with the smaller maximum cumulative execution time is located relatively early in the overall process. Prioritizing the optimization of this node can produce the greatest improvement effect on the cumulative execution time of all subsequent operation nodes, that is, blocking the accumulation of latency earlier from the source, thus maximizing the optimization benefits of the overall process.

[0065] For example, in a credit approval scenario in the financial sector, a directed acyclic graph model includes nodes for filling out a loan application, uploading credit information, facial recognition verification, risk control system review, credit limit approval, electronic contract signing, and loan disbursement confirmation. The server obtains the independent time consumption for each operation node as follows: loan application filling 0s, credit information upload 3s, facial recognition verification 5s, risk control system review 7s, credit limit approval 10s, electronic contract signing 7s, and loan disbursement confirmation 6s. The server determines the maximum independent time consumption to be 10s and identifies the credit limit approval node (with an independent time consumption of 10s) as a candidate bottleneck node. At this point, there is only one candidate bottleneck node, and the server designates the credit limit approval node as the bottleneck node.

[0066] For example, in the online consultation scenario in the medical field, the directed acyclic graph model includes nodes for symptom input, department selection, doctor selection, description of illness, order confirmation, online payment, and consultation completion. The server obtains the independent time consumption for each operation node as follows: symptom input node 0s, department selection node 2s, doctor selection node 3s, description of illness node 3s, order confirmation node 5s, online payment node 3s, and consultation completion node 3s. The server determines the maximum independent time consumption to be 5s and identifies the order confirmation node with an independent time consumption of 5s as a candidate bottleneck node. At this point, there is only one candidate bottleneck node, and the server identifies the order confirmation node as the bottleneck node.

[0067] This embodiment determines the maximum independent time by comparing the independent time of each operation node, and sets up a secondary optimization mechanism for candidate bottleneck nodes: when multiple operation nodes have the same maximum independent time, the operation node with the minimum maximum cumulative time is selected as the bottleneck node. This mechanism ensures that the location of the bottleneck node accurately reflects the independent contribution of each operation node to the overall process delay, and prioritizes the operation node closer to the process start point when multiple high-contribution nodes coexist, so that subsequent optimization can stop the accumulation of delay earlier and achieve better optimization results.

[0068] It should be noted that the data involved in the above embodiments of this application are for illustrative purposes only and do not represent real data, nor should they be construed as any limitation on the scope of protection of this application.

[0069] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0070] Secondly, embodiments of this application provide a bottleneck node determination device, which corresponds one-to-one with the bottleneck node determination methods described in the above embodiments. For example... Figure 3 As shown, the bottleneck node determination device includes an acquisition module 201, a construction module 202, a first determination module 203, a first calculation module 204, a second calculation module 205, and a second determination module 206. Detailed descriptions of each functional module are as follows: The acquisition module 201 is used to acquire the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, and each operation event has an operation identifier and a trigger time; Construction module 202 is used to construct a directed acyclic graph model based on the sequence of operation events; The first determining module 203 is used to determine the starting operation node with an in-degree of zero in the directed acyclic graph model. The first calculation module 204 is used to recursively calculate the maximum cumulative time consumption and its path predecessor for each operation node, starting from the initial operation node. The second calculation module 205 is used to calculate the independent time consumption of each operation node, wherein the independent time consumption is the difference between the maximum cumulative time consumption of the operation node and the maximum cumulative time consumption of its path predecessor. The second determining module 206 is used to determine the bottleneck node in the target business process based on the independent time consumption corresponding to each of the operation nodes.

[0071] In one embodiment, the acquisition module 201 is further configured to: Based on the operation behavior triggered by the target user on the application interface, an operation event record is generated, and each operation event record includes an operation identifier and a trigger time; Obtain the start operation identifier and end operation identifier corresponding to the target business process; From the generated operation event records, filter out operation event records whose operation identifiers belong to the target business process and whose trigger times are between the trigger times corresponding to the start operation identifier and the trigger times corresponding to the end operation identifier; The selected operation event records are sorted in ascending order of trigger time to obtain the operation event sequence.

[0072] In one embodiment, the construction module 202 is further configured to: For each operation event in the operation event sequence, an operation node is created, and the operation identifier of the operation event is used as the identifier of the created operation node; Sequentially obtain each pair of adjacent operation events in the operation event sequence, arranged in ascending order of trigger time, and determine the operation event with the earlier trigger time as the first operation event and the operation event with the later trigger time as the second operation event; A directed edge is established between the operation node corresponding to the earlier operation event and the operation node corresponding to the later operation event, and the direction of the directed edge is from the operation node corresponding to the earlier operation event to the operation node corresponding to the later operation event. The time difference between the triggering of the preceding operation event and the subsequent operation event is used as the edge weight of the established directed edge. Perform loop detection on the directed graph obtained after establishing directed edges; If a cycle exists, remove the directed edge with the smallest weight from all directed edges that form the cycle, and perform cycle detection again on the directed graph after removing the directed edge with the smallest weight, until the detection result indicates that there is no cycle in the graph, and take the directed graph with no cycle as the directed acyclic graph model. If no loop exists, the directed graph is defined as the directed acyclic graph model.

[0073] In one embodiment, after constructing the directed acyclic graph model, the construction module 202 is further configured to: For each operation node in the directed acyclic graph model, a predecessor association list is generated for that operation node. Each entry in the predecessor association list contains the identifier of a predecessor operation node and the edge weight of the directed edge from the predecessor operation node to the operation node. Using the identifier of the operation node as the key and the predecessor association list as the value, the key-value pair is stored in the Redis RMap data structure.

[0074] In one embodiment, the first determining module 203 is further configured to: Set the initial in-degree count to zero for each operation node in the directed acyclic graph model; Traverse each directed edge in the directed acyclic graph model, and for the endpoint node of each directed edge, increment its in-degree count by 1; The operation node with an in-degree count of zero is determined as the starting operation node.

[0075] In one embodiment, the first computing module 204 is further configured to: Set the maximum cumulative time of the starting operation node to zero, and set the path predecessor of the starting operation node to empty; The operation nodes in the directed acyclic graph model are topologically sorted to obtain the node processing sequence; According to the order of the node processing sequence, each operation node is taken out as the current operation node in turn, until all operation nodes in the node processing sequence have been taken out; For each of the current operation nodes, the following is executed: Obtain all predecessor operation nodes of the current operation node, and the edge weights of the directed edges from each predecessor operation node to the current operation node. For each of the preceding operation nodes, the sum of the maximum cumulative time of the preceding operation node and the corresponding edge weight is calculated as the cumulative time of the candidate path. The maximum value among the cumulative time of each candidate path is determined as the maximum cumulative time of the current operation node, and the predecessor operation node that obtains the maximum value is recorded as the path predecessor of the current operation node.

[0076] In one embodiment, the second determining module 206 is further configured to: Obtain the independent time consumption of each of the operation nodes; Determine the maximum independent time from each of the aforementioned independent times; The operation node whose independent time is equal to the maximum independent time is identified as a candidate bottleneck node; If there is only one candidate bottleneck node, then that candidate bottleneck node is determined as the bottleneck node. If there are multiple candidate bottleneck nodes, the candidate bottleneck node with the smallest maximum cumulative time is selected from among the multiple candidate bottleneck nodes as the bottleneck node.

[0077] Specific limitations regarding the bottleneck node determination device can be found in the limitations of the bottleneck node determination method described above, and will not be repeated here. Each module in the aforementioned bottleneck node determination device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in the computer device in hardware form, or stored in the memory of the computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0078] Thirdly, embodiments of this application provide a computer device, which can be a server, and its internal structure diagram can be as follows. Figure 4As shown. The computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with external clients via a network connection. When the computer program is executed by the processor, it implements a bottleneck node determination method on the server side, providing server-side functions or steps.

[0079] In one embodiment, this application provides a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it performs the following steps: Obtain the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, each operation event having an operation identifier and a trigger time; Based on the sequence of operation events, construct a directed acyclic graph model; In the directed acyclic graph model, determine the starting operation node with an in-degree of zero; Starting from the initial operation node, the maximum cumulative time consumption and its path predecessor for each operation node are calculated recursively. For each operation node, calculate the independent time consumption of that operation node, where the independent time consumption is the difference between the maximum cumulative time consumption of that operation node and the maximum cumulative time consumption of its predecessor along the path. Based on the independent time consumption corresponding to each operation node, the bottleneck node in the target business process is determined.

[0080] Fourthly, embodiments of this application provide a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, performs the following steps: Obtain the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, each operation event having an operation identifier and a trigger time; Based on the sequence of operation events, construct a directed acyclic graph model; In the directed acyclic graph model, determine the starting operation node with an in-degree of zero; Starting from the initial operation node, the maximum cumulative time consumption and its path predecessor for each operation node are calculated recursively. For each operation node, calculate the independent time consumption of that operation node, where the independent time consumption is the difference between the maximum cumulative time consumption of that operation node and the maximum cumulative time consumption of its predecessor along the path. Based on the independent time consumption corresponding to each operation node, the bottleneck node in the target business process is determined.

[0081] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions of the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0082] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory may include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), RAMbus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0083] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0084] It should be noted that any AI models, software tools, or components not belonging to this company appearing in the embodiments of this application are merely illustrative examples and do not represent actual use. All user personal information involved in the embodiments of this application has been authorized (with the knowledge and consent) by the relevant parties or has been fully authorized by all parties, and the executing entity may obtain it through various legal and compliant means. The collection, storage, use, processing, transmission, provision, and disclosure of the information, data, and signals involved all comply with relevant laws and regulations and do not violate public order and good morals.

[0085] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.

Claims

1. A method for determining bottleneck nodes, characterized in that, include: Obtain the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, each operation event having an operation identifier and a trigger time; Based on the sequence of operation events, construct a directed acyclic graph model; In the directed acyclic graph model, determine the starting operation node with an in-degree of zero; Starting from the initial operation node, the maximum cumulative time consumption and its path predecessor for each operation node are calculated recursively. For each operation node, calculate the independent time consumption of that operation node, where the independent time consumption is the difference between the maximum cumulative time consumption of that operation node and the maximum cumulative time consumption of its predecessor along the path. Based on the independent time consumption corresponding to each operation node, the bottleneck node in the target business process is determined.

2. The method according to claim 1, characterized in that, The acquisition of the target user's operation event sequence in the target business process includes: Based on the operation behavior triggered by the target user on the application interface, an operation event record is generated, and each operation event record includes an operation identifier and a trigger time; Obtain the start operation identifier and end operation identifier corresponding to the target business process; From the generated operation event records, filter out operation event records whose operation identifiers belong to the target business process and whose trigger times are between the trigger times corresponding to the start operation identifier and the trigger times corresponding to the end operation identifier; The selected operation event records are sorted in ascending order of trigger time to obtain the operation event sequence.

3. The method according to claim 1, characterized in that, The step of constructing a directed acyclic graph model based on the sequence of operation events includes: For each operation event in the operation event sequence, an operation node is created, and the operation identifier of the operation event is used as the identifier of the created operation node; Sequentially obtain each pair of adjacent operation events in the operation event sequence, arranged in ascending order of trigger time, and determine the operation event with the earlier trigger time as the first operation event and the operation event with the later trigger time as the second operation event; A directed edge is established between the operation node corresponding to the earlier operation event and the operation node corresponding to the later operation event, and the direction of the directed edge is from the operation node corresponding to the earlier operation event to the operation node corresponding to the later operation event. The time difference between the triggering of the preceding operation event and the subsequent operation event is used as the edge weight of the established directed edge. Perform loop detection on the directed graph obtained after establishing directed edges; If a cycle exists, remove the directed edge with the smallest weight from all directed edges that form the cycle, and perform cycle detection again on the directed graph after removing the directed edge with the smallest weight, until the detection result indicates that there is no cycle in the graph, and take the directed graph with no cycle as the directed acyclic graph model. If no loop exists, the directed graph is defined as the directed acyclic graph model.

4. The method according to claim 3, characterized in that, After constructing the directed acyclic graph model, the following is also included: For each operation node in the directed acyclic graph model, a predecessor association list is generated for that operation node. Each entry in the predecessor association list contains the identifier of a predecessor operation node and the edge weight of the directed edge from the predecessor operation node to the operation node. Using the identifier of the operation node as the key and the predecessor association list as the value, the key-value pair is stored in the Redis RMap data structure.

5. The method according to claim 1, characterized in that, The step of determining the starting operation node with an in-degree of zero in the directed acyclic graph model includes: Set the initial in-degree count to zero for each operation node in the directed acyclic graph model; Traverse each directed edge in the directed acyclic graph model, and for the endpoint node of each directed edge, increment its in-degree count by 1; The operation node with an in-degree count of zero is determined as the starting operation node.

6. The method according to claim 1, characterized in that, The step of recursively calculating the maximum cumulative time and its path predecessor for each operation node, starting from the initial operation node, includes: Set the maximum cumulative time of the starting operation node to zero, and set the path predecessor of the starting operation node to empty; The operation nodes in the directed acyclic graph model are topologically sorted to obtain the node processing sequence; According to the order of the node processing sequence, each operation node is taken out as the current operation node in turn, until all operation nodes in the node processing sequence have been taken out; For each of the current operation nodes, the following is executed: Obtain all predecessor operation nodes of the current operation node, and the edge weights of the directed edges from each predecessor operation node to the current operation node. For each of the preceding operation nodes, the sum of the maximum cumulative time of the preceding operation node and the corresponding edge weight is calculated as the cumulative time of the candidate path. The maximum value among the cumulative time of each candidate path is determined as the maximum cumulative time of the current operation node, and the predecessor operation node that obtains the maximum value is recorded as the path predecessor of the current operation node.

7. The method according to claim 1, characterized in that, The step of determining the bottleneck node in the target business process based on the independent time consumption corresponding to each of the operation nodes includes: Obtain the independent time consumption of each of the operation nodes; Determine the maximum independent time from each of the aforementioned independent times; The operation node whose independent time is equal to the maximum independent time is identified as a candidate bottleneck node; If there is only one candidate bottleneck node, then that candidate bottleneck node is determined as the bottleneck node. If there are multiple candidate bottleneck nodes, the candidate bottleneck node with the smallest maximum cumulative time is selected from among the multiple candidate bottleneck nodes as the bottleneck node.

8. A bottleneck node determination device, characterized in that, include: The acquisition module is used to acquire the sequence of operation events of the target user in the target business process, wherein the sequence of operation events includes multiple operation events, each operation event having an operation identifier and a trigger time; The construction module is used to construct a directed acyclic graph model based on the sequence of operation events; The first determining module is used to determine the starting operation node with an in-degree of zero in the directed acyclic graph model. The first calculation module is used to recursively calculate the maximum cumulative time consumption and its path predecessor for each operation node, starting from the initial operation node. The second calculation module is used to calculate the independent time consumption of each operation node, wherein the independent time consumption is the difference between the maximum cumulative time consumption of the operation node and the maximum cumulative time consumption of its path predecessor. The second determining module is used to determine the bottleneck node in the target business process based on the independent time consumption corresponding to each of the operation nodes.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the bottleneck node determination method as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the bottleneck node determination method as described in any one of claims 1 to 7.

Images