A server reliability test method and system based on load simulation

Abstract

The present application relates to the technical field of load simulation test, in particular to a server reliability test method and system based on load simulation, in the present application, the switching direction of the check section is verified, and the section stay time sequence is written, to provide a deterministic time anchor point for subsequent multiple rounds of reproduction experiments, a Markov chain is introduced based on the load sequence to model the request instance generation process, so that the arrival sequence and state transition probability of concurrent requests during the section duration are consistent, so that the request delivery process presents controlled randomness, based on the error response count, request timeout span and service interruption duration collected in the running set, a Bayesian variable point detection is introduced to analyze the probability distribution change of the data sequence in the same section, through the calculation and sorting of the change amplitude, the abnormal identification is changed from the threshold triggering to the posterior probability change judgment, so that the system state mutation position can be located when the load intensity does not reach the upper limit.

Description

Technical Field

[0001] This invention relates to the field of load simulation testing technology, and in particular to a server reliability testing method and system based on load simulation. Background Technology

[0002] The field of load simulation testing technology aims to systematically evaluate the operational stability, failure patterns, and performance degradation boundaries of a target system under different load intensities, load combinations, and load variations during the testing phase by constructing a controllable and reproducible workload model and applying the workload model to the operating environment of the server or computer system under test. This provides a quantitative testing basis for server reliability assessment, capacity planning, and online risk control.

[0003] The purpose of a server reliability testing method based on load simulation is to construct a load model that matches the operating characteristics of the target server and apply test requests to the server under test according to predetermined load intensity and load change rules. This allows for the quantitative acquisition of server operating status data under continuous operation and high load conditions without introducing real business traffic. The method clarifies the error frequency, service interruption conditions, and performance degradation threshold of the server under different load levels, determines whether the server meets preset reliability indicators, identifies potential stability risks before server deployment, and reduces the probability of system failures during actual operation.

[0004] Existing load simulation tests typically use a preset number of requests or a fixed concurrency level as the basis for load application. There is no clear correlation between load intensity and the server's internal thread pool capacity, scheduling limits, and processor usage. This means that even if the number of requests changes during the test, the server's internal resource allocation may still remain within the same scheduling range. Consequently, the test results cannot accurately reflect the impact of resource boundary changes on stability. Load changes often employ linear increments or simple step-by-step switching, with request channels maintaining a continuous connection. There is a lack of characterization of connection rebuilding and resource release scenarios, causing factors such as thread reuse and cache residue to mask the true load switching costs, making it difficult to expose bottlenecks during the testing phase. The risk of anomalies during switching is significant, and existing technologies often rely on the number of errors and response times exceeding fixed thresholds as the basis for judgment. This approach assumes that system state changes exhibit a monotonous trend, ignoring potential abrupt changes in statistical distribution within load segments. When high load has not lasted long enough, potential instability phenomena are often masked by the mean and go undetected. Existing technologies analyze the results of each round of testing independently, lacking a mechanism to align and compare differences between different rounds at the same time position. This makes it difficult to distinguish between random jitter and systemic degradation, reducing the ability to identify hidden stability problems. As a result, server reliability assessment remains largely at the statistical level, making it difficult to support accurate risk location and pre-deployment decision-making. Summary of the Invention

[0005] The purpose of this invention is to address the shortcomings of existing technologies by proposing a server reliability testing method and system based on load simulation.

[0006] To achieve the above objectives, the present invention adopts the following technical solution: a server reliability testing method based on load simulation, comprising the following steps: S1: Based on the server's maximum number of processing threads, the maximum number of acceptable requests per unit time, and the maximum processor utilization ratio, divide the thread pool capacity range and map the request concurrency range, verify the segment switching direction and write the segment dwell time order to obtain the load sequence. S2: Based on the load sequence, a Markov chain is used to generate a corresponding number of request instances and establish a connection order. During the duration of the segment, concurrent requests are deployed and thread occupancy changes are recorded. At the segment switching node, the request channel is closed and rebuilt and the segment identifier is written to generate a running set. S3: Based on the running set, Bayesian variable point detection is used to sort the error response counts of the same segment and calculate the change range. The request timeout span and service interruption duration are converted and compared with the threshold. The segment identifier is written according to the judgment result to obtain the risk segment. S4: Based on the load sequence, repeatedly trigger the same load sequence and keep the segment dwell time consistent, align the start time of each round of request channels, calculate the round difference at the same time position and arrange them in order to obtain the difference sequence; S5: Based on the difference sequence, compare the difference changes within a continuous time window and determine the threshold, mark the time point of state change and match it with the risk segment, and establish a trigger table.

[0007] As a further embodiment of the present invention, the load segment identifier includes a range of concurrent request quantity, a range of request sending rate, and a range of processor occupancy ratio; the running status record includes an error response count, a request timeout count, and a service interruption identifier; the load segment set includes corresponding load range information and an abnormal status identifier; the difference item includes an error response difference, a request timeout difference, and a service interruption status difference; and the correspondence includes a time identifier, a load segment identifier, and an abnormal type identifier.

[0008] As a further aspect of the present invention, the specific steps for generating the load sequence are as follows: Based on the upper limit of the number of server processing threads, the upper limit of the number of requests that can be accepted per unit time, and the upper limit of the processor utilization ratio, the thread pool capacity is divided into multiple value ranges according to a fixed gradient. A unique segment number is assigned to each range. A correspondence is established between the range of concurrent request quantities and the segment number, and the data is written into the segment attribute record to obtain the load segment table. Based on the load segment table, the switching direction between segment numbers is checked one by one to see if it meets the preset constraints. Segment paths that are not allowed to switch are removed. The remaining segments are arranged in the order of verification, and a dwell time identifier is written for each segment to generate a load sequence.

[0009] As a further aspect of the present invention, the specific steps for generating the running set are as follows: Based on the load sequence, a Markov chain is used to sequentially read the number of concurrent requests, the request sending rhythm, and the segment dwell time for each load segment. The number of concurrent requests is expanded into specific request entries and assigned a unique number. These entries are written into a list in segment order to generate a request instance set. Based on the request instance set, connection channels are allocated to the request entries in numerical order, and the number of connections opened at the same time is controlled to not exceed the segment concurrency limit. Requests are continuously delivered during the segment dwell time and the corresponding thread number and occupation duration are recorded to obtain the thread occupation record. Based on the thread occupancy record, the current connection channel is closed and the thread number is released at the segment switching time point. Then, the connection channel of the next load segment is started, and the thread occupancy status, request status and segment identifier are summarized and written into the set to generate the running set.

[0010] As a further aspect of the present invention, the Markov chain first reads the load segment set and establishes a state number set, writes low load state number, medium load state number, high load state number and overload state number, constructs a state transition probability matrix and sums and verifies the probability values ​​in each row to ensure that the result is equal to 1, constructs a set of states that can be reached under overload conditions and deletes state numbers that are not allowed to transition, sets a random number generation seed and initializes the current state number, generates random numbers cyclically according to the segment switching step size and accumulates and compares them in the corresponding rows of the state transition probability matrix to determine the next state number, writes the next state number sequentially into the load segment sequence and updates the current state number, expands the state number into continuous time slices according to the segment dwell time and writes them into the time slice sequence to obtain the load segment switching sequence.

[0011] As a further aspect of the present invention, the specific steps for generating the risk segment are as follows: Based on the running set, Bayesian variable point detection is used to collect the number of error responses, the number of request timeouts, and the service interruption identifiers according to the load segment identifier. The original occurrence order is maintained and written into the segment record entries to form a statistical set divided by segment, resulting in a segment count table. Based on the segment count table, the difference between the number of error responses and the number of request timeouts in the records of adjacent segments is calculated, and the start and end times of service interruption are converted into duration and uniformly written into the segment change record to form a segment change table. Based on the segment change table, each change record is read and compared with a preset threshold. Segments that exceed the threshold are written to the abnormal set, and the remaining segment identifiers are written to the normal set. Finally, the abnormal segment identifiers are summarized to obtain the risk segments.

[0012] As a further aspect of the present invention, the Bayesian change point detection involves reading the difference change sequence and setting a start time index, setting prior distribution parameters and observation likelihood distribution parameters, initializing the run length probability vector and writing initial probability values, reading difference values ​​at each time point and updating the observation sufficient statistics, calculating the probability of maintaining the run length and the probability of generating a new change point and completing the normalization calculation, generating the posterior probability distribution of the run length at the current time point and writing it into the probability matrix, calculating the posterior probability of the change point and comparing it with a decision threshold, writing the change point time index set when the posterior probability of the change point exceeds the decision threshold, and outputting the change point time index set and the corresponding posterior probability sequence.

[0013] As a further aspect of the present invention, the specific steps for generating the differential sequence are as follows: Based on the load sequence, multiple rounds of load execution are repeatedly triggered according to the segment arrangement order. In each round, the dwell time of each segment is kept consistent. A time stamp is started on the execution record request channel for each round, and the time stamps of multiple rounds are uniformly mapped to the same time axis to obtain time-aligned records. Based on the time-aligned records, select the same time position under a unified time axis, extract the corresponding running counts for each round of execution, calculate the pairwise differences of the running counts at the same time position, and write them into the result set in chronological order to obtain the difference sequence.

[0014] As a further aspect of the present invention, the specific steps for generating the trigger table are as follows: Based on the difference sequence, the continuous difference interval is divided according to a fixed-length time window. The difference change range is summarized in each time window, and the change range is compared with the threshold item by item. Time points that exceed the threshold are written into the anomaly marker set to obtain the change time point set. Based on the set of change time points, the load segment identifier corresponding to each time point is read one by one, a correspondence is established between the time points and the risk segments, and the correspondence is written into a structured mapping record to establish a trigger table.

[0015] A server reliability testing system based on load simulation, the system being used to execute the aforementioned server reliability testing method based on load simulation, the system comprising: Load segment construction module: Based on the server's maximum number of processing threads, the maximum number of acceptable requests per unit time, and the maximum processor utilization ratio, the module divides the thread pool capacity range and maps the request concurrency range, verifies the segment switching direction, and writes the segment dwell time sequence to obtain the load sequence. Request loading module: Based on the load sequence, a Markov chain is used to generate a corresponding number of request instances and establish a connection order. During the duration of the segment, concurrent requests are deployed and thread occupancy changes are recorded. At the segment switching node, the request channel is closed and rebuilt and the segment identifier is written to generate a running set. Anomaly segment determination module: Based on the running set, Bayesian variable point detection is used to sort the error response counts of the same segment and calculate the change range, convert the request timeout span and service interruption duration and compare them with the threshold, and write the segment identifier according to the judgment result to obtain the risk segment; Replay Difference Generation Module: Based on the load sequence, repeatedly trigger the same load sequence while maintaining consistent segment dwell time, align the start time of each round of request channels, calculate the round differences at the same time position and arrange them in order to obtain the difference sequence; Trigger mapping establishment module: Based on the difference sequence, compare the difference changes within a continuous time window and determine the threshold, mark the time point of state change and match it with the risk segment to establish a trigger table.

[0016] Compared with the prior art, the advantages and positive effects of the present invention are as follows: In this invention, the thread pool capacity range is divided by the upper limit of the number of processing threads, the upper limit of the number of acceptable requests per unit time, and the upper limit of the processor occupancy ratio. The capacity range is then mapped to the request concurrency range, so that the load building process is changed from being controlled by the number of external requests to being directly related to the state of the schedulable resources inside the server, thus avoiding the offset between load description and resource consumption. In this invention, by verifying the direction of segment switching and writing the sequence of segment dwell time, the load change process is subject to strict time constraints, providing deterministic time anchors for subsequent multi-round reproduction experiments. Based on the load sequence, a Markov chain is introduced to model the request instance generation process, ensuring that the arrival order of concurrent requests during the segment duration is consistent with the state transition probability, making the request delivery process exhibit controlled randomness, and avoiding the discrete results caused by uncontrollable request distribution in traditional load replay. In this invention, the request channel is closed and rebuilt at the segment switching node, thus establishing a clear boundary between the connection lifecycle and the load segment. This causes thread release, reallocation, and segment changes to occur synchronously, allowing changes in thread occupancy to be precisely attributed to a specific load segment. In this invention, based on the error response count, request timeout span, and service interruption duration collected in the running set, Bayesian change point detection is introduced to perform probability distribution change analysis on the data sequence within the same segment. By calculating and sorting the change amplitude, the anomaly identification is transformed from threshold triggering to judgment based on posterior probability change, so that the location of system state change can be located when the load intensity has not reached the upper limit. In this invention, by repeatedly triggering the same load sequence and keeping the segment dwell time consistent, and aligning the start time of each round of request channels, the results of different rounds of operation are made to correspond one-to-one on the time axis. By calculating the round differences at the same time position to form a difference sequence, random fluctuations and structural degradation are separable. Attached Figure Description

[0017] Figure 1 This is a schematic diagram of the workflow of the present invention; Figure 2 This is a system flowchart of the present invention. Detailed Implementation

[0018] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0019] Example 1 Please see Figure 1 This invention provides a technical solution: a server reliability testing method based on load simulation, comprising the following steps: S1: Based on the server's maximum number of processing threads, the maximum number of acceptable requests per unit time, and the maximum processor utilization ratio, divide the thread pool capacity range and map the request concurrency range, verify the segment switching direction and write the segment dwell time order to obtain the load sequence. S2: Based on the load sequence, using a Markov chain, generate a corresponding number of request instances and establish a connection order. During the duration of the segment, concurrent requests are deployed and thread usage changes are recorded. At the segment switching node, the request channel is closed and rebuilt and the segment identifier is written to generate a running set. S3: Based on the running set, Bayesian variable point detection is used to sort the error response counts of the same segment and calculate the change range. The request timeout span and service interruption duration are converted and compared with the threshold. The results are written into the segment identifier to obtain the risk segment. S4: Based on the load sequence, repeatedly trigger the same load order and keep the segment dwell time consistent, align the start time of each round of request channels, calculate the round difference at the same time position and arrange them in order to obtain the difference sequence; S5: Based on the differential sequence, compare the differential changes within a continuous time window and determine the threshold, mark the time points of state change and match them with the risk segment, and establish a trigger table.

[0020] The load segment identifier includes the range of concurrent request quantity, request sending rate, and processor utilization ratio. The running status record includes error response count, request timeout count, and service interruption identifier. The load segment set includes corresponding load range information and abnormal status identifier. The difference items include error response difference, request timeout difference, and service interruption status difference. The correspondence includes time identifier, load segment identifier, and abnormal type identifier.

[0021] The specific steps for generating the load sequence are as follows: Based on the upper limit of the number of server processing threads, the upper limit of the number of requests that can be accepted per unit time, and the upper limit of the processor utilization ratio, the thread pool capacity is divided into multiple value ranges according to a fixed gradient. A unique segment number is assigned to each range. A correspondence is established between the range of concurrent request quantities and the segment number, and the data is written into the segment attribute record to obtain the load segment table. Based on the load segment table, the switching direction between segment numbers is checked one by one to see if it meets the preset constraints. Segment paths that are not allowed to switch are removed. The remaining segments are arranged in the order of verification, and a dwell time identifier is written for each segment to generate a load sequence. Based on the server's maximum number of processing threads, the maximum number of acceptable requests per unit time, and the maximum processor utilization ratio, a fixed gradient discrete partitioning method is used to perform interval processing on the thread pool capacity. Specifically, the maximum number of threads is read from the server configuration items, the thread pool capacity partitioning step is set to a fixed integer of ten, and ten consecutive thread counts are used as a value interval, generating multiple consecutive intervals sequentially. A proportional mapping method is used for the maximum number of acceptable requests per unit time, with the ratio parameter set to a fixed value of 1.5. The lower limit and upper limit of concurrent requests are calculated based on the thread count range corresponding to the current interval. The processor utilization ratio is then adjusted accordingly. The upper limit of the ratio is set to a fixed value of 0.85 and written as a static field in the segment attribute record. A unique integer segment number is assigned to each generated interval. The segment number is written in ascending order according to the interval generation order. For each segment number, the following values ​​are written: lower limit of thread number, upper limit of thread number, lower limit of concurrent request number, upper limit of concurrent request number, and upper limit of processor occupancy ratio. The writing process is performed using a key-value mapping method. The key fields include segment number, lower limit of thread, upper limit of thread, lower limit of request, upper limit of request, and upper limit of occupancy ratio. The value fields are written with the corresponding integer or decimal values. After all segment attributes are written, the load segment table is generated. Based on the load segment table, a directed graph path constraint verification method is used to verify the switching direction between segment numbers. Specifically, each segment number is mapped to a directed graph node, and the allowed switching conditions between segments are limited to forward or reverse movement based on the adjacent number relationship. Segment number combinations that do not meet the adjacent relationship are defined as illegal switching paths and marked during the verification process. All segment number combinations in the load segment table are traversed in numerical order. During the traversal, it is checked whether the current segment number and the target segment number meet the allowed switching conditions. Paths marked as illegal switching are directly removed and not written into subsequent processing. The segment numbers that pass the verification are linearly arranged in the traversal order, and a dwell time identifier is written for each segment. The dwell time identifier is represented in integer seconds, with the minimum dwell time set to 30 seconds and the maximum dwell time set to 300 seconds. The dwell time value is assigned in ascending order according to the position index of the segment in the arrangement order. The segment number and the corresponding dwell time are written into the sequence list structure in sequential pairs. After all segment numbers and dwell time identifiers are written, the load sequence is generated.

[0022] The specific steps for generating the runtime set are as follows: Based on the load sequence, a Markov chain is used to read the number of concurrent requests, the request sending rhythm and the dwell time of each load segment in sequence. The number of concurrent requests is expanded into specific request entries and assigned a unique number. These entries are written into a list in segment order to generate a request instance set. Based on the request instance set, connection channels are allocated to request entries in numerical order to control the number of connections opened at the same time to not exceed the segment concurrency limit. Requests are continuously delivered during the segment dwell time and the corresponding thread number and occupation duration are recorded to obtain the thread occupation record. Based on thread occupancy records, the current connection channel is closed and the thread number is released at the segment switching time point. Then, the connection channel of the next load segment is started. The thread occupancy status, request status and segment identifier are summarized and written into the set to generate the running set. Based on the load sequence, a discrete-time Markov chain generation method is used to sequentially read the number of concurrent requests, request sending rhythm, and segment dwell time corresponding to each load segment. The Markov chain state space is explicitly defined, and the state set is limited to the segment number set. The initial state is set to the first segment number of the load sequence. The state transition matrix is ​​stored in the form of a two-dimensional array. The matrix elements take fixed decimal values ​​to represent the probability of the current segment state transitioning to the state of the next adjacent segment. Only the positions corresponding to the adjacent segment numbers in the load sequence are allowed to be written with non-zero values ​​in the matrix, and the remaining positions are written with zero values. Within each segment, the total number of requests is expanded into specific request entries according to the number of concurrent requests. The request entries are generated using sequential integer numbering. The starting value of the number is set to one, and the number is incremented by one for each generated request entry. Each request entry is written with its own segment number, planned sending timestamp, and status field. The planned sending timestamp is allocated sequentially at fixed time intervals according to the request sending rhythm parameter. The status field is initially written with a pending sending identifier. All request entries are written into a linear list structure according to the segment order in the load sequence. After the expansion of all segment request entries is completed, a request instance set is generated. Based on the request instance set, a sequential connection allocation and concurrent rate limiting method is used to allocate connection channels to each request entry in the order of request entry number. The connection channels are represented by integer numbers. The number pool generates a fixed number of channel numbers during the initialization phase. An upper limit value is set for the number of connections that can be opened at the same time. The upper limit value is read from the concurrent request quantity field of the current segment. During the request delivery process, an active connection counter is maintained. The counter increments by one for each connection opened and decrements by one for each connection closed. When the counter value reaches the concurrent upper limit, the new connection allocation operation is paused. Within the segment dwell time range, the request sending operation is continuously triggered according to the planned sending timestamp order in the request instance set. At the same time as the request is sent, the request entry number, the allocated connection channel number, the allocated thread number, the thread start timestamp, and the thread end timestamp are recorded. The thread number is allocated sequentially from the thread pool. The thread end timestamp is written at the request completion node or timeout node. The above records are continuously appended to the occupancy record table structure in the form of row records. After all requests within the segment are processed, a thread occupancy record is generated. Based on thread occupancy records, a segment switching synchronization control method is adopted to uniformly execute connection channel closure operations at the segment switching time point. Closure commands are sent to all active connection channels one by one, and after closure, the corresponding channel number is recycled to the number pool. The corresponding thread number is synchronously written to the release status. After the release operation is completed, the next load segment number is read and the segment connection channel configuration is initialized. The data already written in the thread occupancy record is summarized. The summary fields include thread number, connection channel number, request entry number, request status, segment number, and timestamp information. The current segment identifier is written to each summary record. Records generated before and after segment switching are written to a unified set structure in chronological order. After all load segments are executed and summarized, a running set is generated.

[0023] The Markov chain process begins by reading the load segment set and establishing a state number set. Low-load, medium-load, high-load, and overload state numbers are then written in. A state transition probability matrix is ​​constructed, and the probability values ​​in each row are summed and verified to ensure the result equals 1. A set of states that are allowed to reach the overload state is constructed, and state numbers that are not allowed to transition are deleted. A random number seed is set, and the current state number is initialized. Random numbers are generated cyclically according to the segment switching step size, and accumulated and compared in the corresponding rows of the state transition probability matrix to determine the next state number. The next state number is sequentially written into the load segment sequence, and the current state number is updated. The state numbers are expanded into continuous time slices according to the segment dwell time and written into the time slice sequence to obtain the load segment switching sequence. Markov chains, according to the formula:

[0024] in: The server load status is indicated by load segment. Transfer to load segment State transition probability value, Indicates the status index number of the current load segment. Indicates the status index number of the target load segment. Indicates the load segment The corresponding dwell time value for the section, Indicates the load segment The corresponding request sending rhythm time interval value, Indicates the load segment The corresponding number of concurrent requests. Indicates the load segment The corresponding confidence coefficient weight value, This represents the value of the pseudo-count parameter used for smoothing state transition probabilities. This indicates the total number of load segments preset during the load simulation process; Execution process: First, determine the total number of load segments according to the preset load sequence. And initialize the current load segment index. And read the concurrent request count parameter corresponding to the load segment. Request to send rhythm time interval parameter and segment dwell time parameters Then calculate the segment Equivalent number of requests sent within To characterize the number of requests a server has the opportunity to handle under load intensity, a concurrency scale correction term is introduced. The nonlinear effects of increased request volume under high concurrency conditions are suppressed, and the above results are compared with the credibility coefficient weight parameters. Multiplication reflects the contribution of the current load segment to the server reliability assessment, and a smoothing pseudo-count parameter is then added on top of this. To avoid a situation where the transfer probability is zero due to insufficient segment transfer attempts, a sequential segment transfer indicator function is then used. Limited to the current segment only Next load segment The transfers are statistically analyzed, and the resulting weighted transfer count is used as the numerator. Simultaneously, the state of all load segments is introduced. As a unified smoothing term, it forms the denominator with the weighted transition count of the current segment, ultimately yielding the state transition probability. The probability is used to determine whether the server should move to the next load segment after completing the reliability test of the current load segment, thereby driving the load simulation process to continue and completing the entire server reliability test process.

[0025] The specific steps for generating risk zones are as follows: Based on the running set, Bayesian variable point detection is used to collect the number of error responses, the number of request timeouts, and the service interruption identifiers according to the load segment identifier. The original occurrence order is maintained and written into the segment record entries to form a statistical set divided by segment, resulting in a segment count table. Based on the segment count table, the difference between the number of error responses and the number of request timeouts in the records of adjacent segments is calculated, and the start and end times of service interruption are converted into duration and uniformly written into the segment change record to form a segment change table. Based on the segment change table, each change record is read and compared with a preset threshold. Segments that exceed the threshold are written into the abnormal set, and the remaining segment identifiers are written into the normal set. Finally, the abnormal segment identifiers are summarized to obtain the risk segments. Based on the running set, a Bayesian variable detection algorithm is used to perform statistical aggregation processing according to the load segment identifier. Specifically, each record is read sequentially from the running set, and the records are divided into corresponding segment cache lists according to the segment identifier field. For each segment cache list, the error response identifier field, request timeout identifier field, and service interruption identifier field are extracted, while maintaining the time order of the records in the running set. Records with a true error response identifier are counted one by one, records with a true request timeout identifier are counted one by one, and records with a true service interruption identifier have their corresponding interruption start timestamp and interruption end timestamp extracted and written sequentially. This process is repeated until all records within the completed segment have been written. Next, the input data is constructed in the form of a time series. The time series elements include the cumulative count of error responses, the cumulative count of request timeouts, and the sequence of service interruption identifiers. The parameters of the Bayesian change point detection algorithm are set, including the prior distribution type being set to Poisson distribution, the prior strength parameter being set to a fixed integer of 1, the likelihood function being selected as Poisson likelihood, and the running mode being set to update the posterior probability point by point. During the sequence traversal, the posterior probability value of the change point is calculated for each new time point and written into the record entry. The corresponding segment number, number of error responses, number of request timeouts, service interruption identifier, and time sequence index of each record are written into the segment statistics structure. After all segments are processed, a segment count table is generated. Based on the segment count table, the difference calculation method between adjacent segments is used to calculate the changes between segments. Specifically, the records in the segment count table are traversed sequentially according to the segment number order. The error response count field corresponding to the current segment and the previous adjacent segment are subtracted item by item and the result is recorded. The request timeout count field corresponding to the current segment and the previous adjacent segment are subtracted item by item and the result is recorded. The timestamp parsing operation is performed on the records in the service interruption identifier sequence. After converting the interruption start timestamp and interruption end timestamp into a unified time unit, the subtraction operation is performed to obtain the corresponding service interruption duration value. The difference in error response count, the difference in request timeout count, and the service interruption duration are written into the segment change record in the form of fields, and the current segment number is written into the associated field. After completing the difference and duration conversion for all adjacent segments, all change records are sequentially written into the change table structure to generate the segment change table. Based on the segment change table, a threshold comparison method is used to read segment change records one by one and perform set partitioning processing. Specifically, each change record is read sequentially from the segment change table, and the error response count difference field, request timeout count difference field, and service interruption duration field are read. These are then compared with the corresponding threshold items in the preset threshold set. The threshold values ​​for error response count difference, request timeout count difference, and service interruption duration are all set to fixed integer values. When the value of any field exceeds the corresponding threshold, the segment identifier of the record is written to the abnormal set structure. When the values ​​of all fields do not exceed the threshold, the segment identifier of the record is written to the normal set structure. After all records in the segment change table have been compared and written, the segment identifiers in the abnormal set are summarized and duplicates are removed. Finally, the risk segment is output.

[0026] Bayesian change point detection reads the difference change sequence and sets the start time index, sets the prior distribution parameters and the observation likelihood distribution parameters, initializes the run length probability vector and writes the initial probability value, reads the difference value at each time point and updates the observation sufficient statistics, calculates the probability of continuing to maintain the run length and the probability of generating a new change point and completes the normalization calculation, generates the posterior probability distribution of the run length at the current time point and writes it into the probability matrix, calculates the posterior probability of the change point and compares it with the decision threshold, when the posterior probability of the change point exceeds the decision threshold, writes it into the change point time index set, and outputs the change point time index set and the corresponding posterior probability sequence. Bayesian variable point detection, according to the formula:

[0027] in: Indicates the time index during the server reliability testing process. The posterior probability value of a load segment change point occurring at that location. This represents the chronological index value of the events occurring in the server load simulation run set. This represents a probability calculation operator used to describe the uncertainty of server operating status. A variable indicating whether a server load segment has switched is a random variable. Indicates the time index during server load simulation. A segment handover event occurred at [location]. Indicates the time index during server load simulation. No segment handover event occurred. Indicates time index The server returns a cumulative or incremental value for the number of error responses. Indicates time index The cumulative or incremental number of times the server request processing has timed out. Indicates time index This is a flag variable indicating a server service interruption, and its value is either 0 or 1. This represents the Poisson distribution strength parameter value for the number of server error responses under load segment switching conditions. This represents the Poisson distribution strength parameter value for the number of server error responses under the condition that no load segment switching occurs. This represents the Poisson distribution strength parameter value for the number of server request timeouts under load segment switching conditions. This represents the Poisson distribution strength parameter value for the number of server request timeouts under the condition that no load segment switching occurs. This represents the Bernoulli distribution probability parameter value for server service interruption under load segment switching conditions. This represents the Bernoulli distribution probability parameter value for a server service interruption under the condition that no load segment switching occurs. This represents the prior probability value of a load segment switching event occurring during server load simulation. This represents the prior probability that no load segment switching event occurred during the server load simulation. This represents the summation index variable used to enumerate the two states of server load segment switching, and its value set is... ; Execution process: First, determine the time index according to the original occurrence order of events in the server load simulation set. Read the number of error responses at the time index. Number of request timeouts Service interruption identifier Subsequently, in the case of a load segment switching state, respectively and no load segment switching occurred Calculate using the Poisson distribution form under both conditions. In parameters and The occurrence likelihood value under constraints is calculated using the Poisson distribution form. In parameters and The occurrence likelihood value under constraints is calculated using the Bernoulli distribution form. In parameters and The occurrence likelihood value under constraints is then multiplied and fused with the three similarity results under the same state assumption, and then respectively compared with the corresponding prior probabilities. and Multiply to construct the numerator and denominator, then by... The combined results are normalized to calculate the posterior probability of the change point. and with As a quantitative basis for determining whether a server load segment has switched, it divides the load segment while keeping the order of running events unchanged, and provides boundary judgment results for subsequent collection of error response counts, request timeout counts, and service interruption identifiers by segment to form a segment count table.

[0028] The specific steps for generating differential sequences are as follows: Based on the load sequence, multiple rounds of load execution are repeatedly triggered according to the segment arrangement order. In each round, the dwell time of each segment is kept consistent. The execution record request channel for each round starts a time stamp, and the time stamps of multiple rounds are uniformly mapped to the same time axis to obtain time-aligned records. Based on time-aligned records, select the same time position under a unified time axis, extract the corresponding running counts for each round of execution, calculate the pairwise difference of the running counts at the same time position, and write them into the result set in chronological order to obtain the difference sequence; Based on the load sequence, a multi-round deterministic replay and linear time axis mapping method is adopted to repeatedly trigger multiple rounds of load execution according to the segment arrangement order. Specifically, all segment numbers and corresponding dwell time identifiers in the load sequence are read, and the starting value of the round count is set to increment sequentially. For each round of execution, a round identifier is written at the startup phase. In each round, the segment execution is triggered sequentially according to the load sequence order, and the request channel start time mark is recorded at the segment switching node. The request channel start time mark is recorded as an integer millisecond value in the form of a system timestamp. An independent time mark list is generated for each round. After all rounds of execution are completed, a unified time axis mapping process is performed on all round time mark lists. The mapping method adopts a linear alignment rule, taking the start time of the first request channel in each round as the zero point reference, converting the remaining time marks into relative time offset values, and mapping the same relative time offset positions in different rounds to a unified time axis scale. Time points that cannot be precisely aligned are merged to the nearest time scale by rounding down. The round number and corresponding relative time offset value are written to each time scale. After completing the time mark mapping of all rounds, a time alignment record is generated. Based on time-aligned records, a unified time-axis difference calculation method is used to perform run count difference extraction processing under the same time axis. Specifically, each time position is read one by one according to the time axis scale order. At each time position, the run count value corresponding to all rounds is extracted. The run count value comes from the cumulative number of completed requests within the corresponding segment of the time position. For any two rounds of run count values ​​at the same time position, pairwise difference calculation is performed. The difference calculation adopts the direct numerical subtraction method and retains the positive and negative signs. Multiple difference results generated at the same time position are written into the difference list according to the round number order. After all difference values ​​are written for the current time position, the next time position is processed. After the difference calculation is completed for all time positions, the difference results are written into the result set structure in the order of the time axis scale. After all difference values ​​are written, a difference sequence is generated.

[0029] The specific steps for generating the trigger table are as follows: Based on the differential sequence, the continuous difference interval is divided according to a fixed-length time window. The difference change range is summarized in each time window, and the change range is compared with the threshold item by item. Time points that exceed the threshold are written into the anomaly marker set to obtain the change time point set. Based on the set of changing time points, the load segment identifier corresponding to each time point is read one by one, a correspondence is established between the time points and the risk segments, and the correspondence is written into the structured mapping record to establish a trigger table; Based on the difference sequence, a fixed-window sliding aggregation method is used to divide continuous difference records into intervals according to a fixed-length time window. Specifically, all records in the difference sequence are read and arranged in order of the time axis scale. The time window length is set to a fixed integer second value, and the window step size is set to be consistent with the window length. Starting from the timestamp of the first record in the difference sequence, the algorithm slides sequentially. Within each time window, all difference records falling within the window's time range are extracted. The extracted difference records are then subjected to a change amplitude summarization operation. The summarization method uses absolute value accumulation. For each difference record, the absolute value operation is performed first, followed by a line-by-line summarization. The cumulative operation obtains the total change in difference within the time window, and compares the change with the corresponding threshold item in the preset threshold table one by one. The threshold values ​​in the threshold table are written in fixed integer form. When the total change exceeds the threshold, the set of timestamps corresponding to the difference records in the time window is read, and the timestamps are written into the anomaly mark set structure one by one. When the total change does not exceed the threshold, no writing operation is performed. After completing the processing of the current time window, the process moves to the next time window until the entire time range is covered. The set of change time points is output after all the timestamps written in the anomaly mark set are sorted in chronological order. Based on the set of changing time points, a time point segment mapping construction method is adopted to read each time point one by one and perform segment association processing. Specifically, timestamp records are read sequentially from the set of changing time points. An interval matching operation is performed by matching the timestamp with the time field of the records in the running set to locate the segment identifier that the timestamp falls within the corresponding load segment stay time range. After determining a unique corresponding segment identifier for each timestamp, the timestamp and segment identifier are written into the mapping cache structure in key-value form. At the same time, the segment identifier list in the risk segment set is read, and an inclusion judgment operation is performed on the current segment identifier. When the segment identifier exists in the risk segment set, the timestamp, segment identifier, and risk identifier fields are written into the mapping record structure. When the segment identifier does not exist in the risk segment set, the timestamp and segment identifier are written into the mapping record structure, and the risk identifier field is set to negative. After all timestamps in the set of changing time points have been mapped and written, the mapping record structure is sorted in ascending order by timestamp and duplicate timestamp records are removed to generate a trigger table.

[0030] A server reliability testing system based on load simulation, used to execute the aforementioned server reliability testing method based on load simulation, the system comprising: Load segment construction module: Based on the server's maximum number of processing threads, the maximum number of acceptable requests per unit time, and the maximum processor utilization ratio, the module divides the thread pool capacity range and maps the request concurrency range, verifies the segment switching direction, and writes the segment dwell time sequence to obtain the load sequence. The request loading module is based on a load sequence and uses a Markov chain to generate a corresponding number of request instances and establish a connection order. During the duration of a segment, concurrent requests are deployed and changes in thread usage are recorded. At the segment switching node, the request channel is closed and rebuilt and the segment identifier is written to generate a running set. The abnormal segment determination module: Based on the running set, it adopts Bayesian variable point detection, sorts the error response count of the same segment and calculates the change range, converts the request timeout span and service interruption duration and compares it with the threshold, writes the judgment result into the segment identifier, and obtains the risk segment; Replay Difference Generation Module: Based on the load sequence, repeatedly trigger the same load order and keep the segment dwell time consistent, align the start time of each round of request channels, calculate the round difference at the same time position and arrange them in order to obtain the difference sequence; Trigger mapping establishment module: Based on the difference sequence, compare the difference changes within a continuous time window and determine the threshold, mark the time points of state change and match them with risk segments to establish a trigger table.

[0031] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention in any other way. Any person skilled in the art may make changes or modifications to the above-disclosed technical content to create equivalent embodiments that can be applied to other fields. However, any simple modifications, equivalent changes, and modifications made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the protection scope of the present invention.

Claims

1. A server reliability testing method based on load simulation, characterized in that, Includes the following steps: S1: Based on the server's maximum number of processing threads, the maximum number of acceptable requests per unit time, and the maximum processor utilization ratio, divide the thread pool capacity range and map the request concurrency range, verify the segment switching direction and write the segment dwell time order to obtain the load sequence. S2: Based on the load sequence, a Markov chain is used to generate a corresponding number of request instances and establish a connection order. During the duration of the segment, concurrent requests are deployed and thread occupancy changes are recorded. At the segment switching node, the request channel is closed and rebuilt and the segment identifier is written to generate a running set. S3: Based on the running set, Bayesian variable point detection is used to sort the error response counts of the same segment and calculate the change range. The request timeout span and service interruption duration are converted and compared with the threshold. The segment identifier is written according to the judgment result to obtain the risk segment. S4: Based on the load sequence, repeatedly trigger the same load sequence and keep the segment dwell time consistent, align the start time of each round of request channels, calculate the round difference at the same time position and arrange them in order to obtain the difference sequence; S5: Based on the difference sequence, compare the difference changes within a continuous time window and determine the threshold, mark the time point of state change and match it with the risk segment, and establish a trigger table.

2. The server reliability testing method based on load simulation according to claim 1, characterized in that, The load segment identifier includes the range of concurrent request quantity, the range of request sending rate, and the range of processor utilization ratio. The running status record includes error response count, request timeout count, and service interruption identifier. The load segment set includes corresponding load range information and abnormal status identifier. The difference item includes error response difference, request timeout difference, and service interruption status difference. The correspondence includes time identifier, load segment identifier, and abnormal type identifier.

3. The server reliability testing method based on load simulation according to claim 1, characterized in that, The specific steps for generating the load sequence are as follows: Based on the upper limit of the number of server processing threads, the upper limit of the number of requests that can be accepted per unit time, and the upper limit of the processor utilization ratio, the thread pool capacity is divided into multiple value ranges according to a fixed gradient. A unique segment number is assigned to each range. A correspondence is established between the range of concurrent request quantities and the segment number, and the data is written into the segment attribute record to obtain the load segment table. Based on the load segment table, the switching direction between segment numbers is checked one by one to see if it meets the preset constraints. Segment paths that are not allowed to switch are removed. The remaining segments are arranged in the order of verification, and a dwell time identifier is written for each segment to generate a load sequence.

4. The server reliability testing method based on load simulation according to claim 1, characterized in that, The specific steps for generating the aforementioned running set are as follows: Based on the load sequence, a Markov chain is used to sequentially read the number of concurrent requests, the request sending rhythm, and the segment dwell time for each load segment. The number of concurrent requests is expanded into specific request entries and assigned a unique number. These entries are written into a list in segment order to generate a request instance set. Based on the request instance set, connection channels are allocated to the request entries in numerical order, and the number of connections opened at the same time is controlled to not exceed the segment concurrency limit. Requests are continuously delivered during the segment dwell time and the corresponding thread number and occupation duration are recorded to obtain the thread occupation record. Based on the thread occupancy record, the current connection channel is closed and the thread number is released at the segment switching time point. Then, the connection channel of the next load segment is started, and the thread occupancy status, request status and segment identifier are summarized and written into the set to generate the running set.

5. The server reliability testing method based on load simulation according to claim 1, characterized in that, The Markov chain first reads the load segment set and establishes a state number set, then writes low load state number, medium load state number, high load state number, and overload state number. It constructs a state transition probability matrix and sums and verifies the probability values ​​in each row to ensure the result equals 1. It constructs a set of states that are allowed to reach the overload state and deletes state numbers that are not allowed to transition. It sets a random number generation seed and initializes the current state number. It cyclically generates random numbers according to the segment switching step size and accumulates and compares them in the corresponding rows of the state transition probability matrix to determine the next state number. It sequentially writes the next state number into the load segment sequence and updates the current state number. Finally, it expands the state number into continuous time slices according to the segment dwell time and writes them into the time slice sequence to obtain the load segment switching sequence.

6. The server reliability testing method based on load simulation according to claim 1, characterized in that, The specific steps for generating the risk segment are as follows: Based on the running set, Bayesian variable point detection is used to collect the number of error responses, the number of request timeouts, and the service interruption identifiers according to the load segment identifier. The original occurrence order is maintained and written into the segment record entries to form a statistical set divided by segment, resulting in a segment count table. Based on the segment count table, the difference between the number of error responses and the number of request timeouts in the records of adjacent segments is calculated, and the start and end times of service interruption are converted into duration and uniformly written into the segment change record to form a segment change table. Based on the segment change table, each change record is read and compared with a preset threshold. Segments that exceed the threshold are written to the abnormal set, and the remaining segment identifiers are written to the normal set. Finally, the abnormal segment identifiers are summarized to obtain the risk segments.

7. The server reliability testing method based on load simulation according to claim 1, characterized in that, The Bayesian change point detection process involves reading the difference change sequence and setting a start time index, setting prior distribution parameters and observation likelihood distribution parameters, initializing the run length probability vector and writing initial probability values, reading difference values ​​at each time point and updating the observation sufficient statistics, calculating the probability of maintaining the run length and the probability of generating a new change point and completing the normalization calculation, generating the posterior probability distribution of the run length at the current time point and writing it into the probability matrix, calculating the posterior probability of the change point and comparing it with a decision threshold, and writing the change point time index set into the change point time index set when the change point posterior probability exceeds the decision threshold, and outputting the change point time index set and the corresponding posterior probability sequence.

8. The server reliability testing method based on load simulation according to claim 1, characterized in that, The specific steps for generating the differential sequence are as follows: Based on the load sequence, multiple rounds of load execution are repeatedly triggered according to the segment arrangement order. In each round, the dwell time of each segment is kept consistent. A time stamp is started on the execution record request channel for each round, and the time stamps of multiple rounds are uniformly mapped to the same time axis to obtain time-aligned records. Based on the time-aligned records, select the same time position under a unified time axis, extract the corresponding running counts for each round of execution, calculate the pairwise differences of the running counts at the same time position, and write them into the result set in chronological order to obtain the difference sequence.

9. The server reliability testing method based on load simulation according to claim 1, characterized in that, The specific steps for generating the trigger table are as follows: Based on the difference sequence, the continuous difference interval is divided according to a fixed-length time window. The difference change range is summarized in each time window, and the change range is compared with the threshold item by item. Time points that exceed the threshold are written into the anomaly marker set to obtain the change time point set. Based on the set of change time points, the load segment identifier corresponding to each time point is read one by one, a correspondence is established between the time points and the risk segments, and the correspondence is written into a structured mapping record to establish a trigger table.

10. A server reliability testing system based on load simulation, characterized in that, The server reliability testing method based on load simulation according to any one of claims 1-9, wherein the system comprises: Load segment construction module: Based on the server's maximum number of processing threads, the maximum number of acceptable requests per unit time, and the maximum processor utilization ratio, the module divides the thread pool capacity range and maps the request concurrency range, verifies the segment switching direction, and writes the segment dwell time sequence to obtain the load sequence. Request loading module: Based on the load sequence, a Markov chain is used to generate a corresponding number of request instances and establish a connection order. During the duration of the segment, concurrent requests are deployed and thread occupancy changes are recorded. At the segment switching node, the request channel is closed and rebuilt and the segment identifier is written to generate a running set. Anomaly segment determination module: Based on the running set, Bayesian variable point detection is used to sort the error response counts of the same segment and calculate the change range, convert the request timeout span and service interruption duration and compare them with the threshold, and write the segment identifier according to the judgment result to obtain the risk segment; Replay Difference Generation Module: Based on the load sequence, repeatedly trigger the same load sequence while maintaining consistent segment dwell time, align the start time of each round of request channels, calculate the round differences at the same time position and arrange them in order to obtain the difference sequence; Trigger mapping establishment module: Based on the difference sequence, compare the difference changes within a continuous time window and determine the threshold, mark the time point of state change and match it with the risk segment to establish a trigger table.

Images