CN104750607A - Method and device for selectively recovering test execution - Google Patents
Method and device for selectively recovering test execution Download PDFInfo
- Publication number
- CN104750607A CN104750607A CN201510131327.7A CN201510131327A CN104750607A CN 104750607 A CN104750607 A CN 104750607A CN 201510131327 A CN201510131327 A CN 201510131327A CN 104750607 A CN104750607 A CN 104750607A
- Authority
- CN
- China
- Prior art keywords
- sub
- execution
- subprocess
- shared memory
- test
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 739
- 238000012360 testing method Methods 0.000 title claims abstract description 243
- 230000008569 process Effects 0.000 claims description 382
- 238000011084 recovery Methods 0.000 claims description 46
- 230000036961 partial effect Effects 0.000 claims description 13
- 239000000725 suspension Substances 0.000 claims description 7
- 238000011112 process operation Methods 0.000 claims description 6
- 230000008859 change Effects 0.000 abstract description 9
- 238000011056 performance test Methods 0.000 description 37
- 230000006870 function Effects 0.000 description 22
- 238000010586 diagram Methods 0.000 description 14
- 230000003993 interaction Effects 0.000 description 12
- 238000012545 processing Methods 0.000 description 8
- 238000003860 storage Methods 0.000 description 8
- 238000004590 computer program Methods 0.000 description 7
- 230000002452 interceptive effect Effects 0.000 description 6
- 238000001824 photoionisation detection Methods 0.000 description 4
- 230000009471 action Effects 0.000 description 3
- 238000006243 chemical reaction Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 230000009191 jumping Effects 0.000 description 3
- 101000860173 Myxococcus xanthus C-factor Proteins 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000000750 progressive effect Effects 0.000 description 2
- 230000002829 reductive effect Effects 0.000 description 2
- 208000019116 sleep disease Diseases 0.000 description 2
- 238000009662 stress testing Methods 0.000 description 2
- 238000010998 test method Methods 0.000 description 2
- 230000002159 abnormal effect Effects 0.000 description 1
- 230000005856 abnormality Effects 0.000 description 1
- 230000004075 alteration Effects 0.000 description 1
- 238000004458 analytical method Methods 0.000 description 1
- 230000006399 behavior Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 125000004122 cyclic group Chemical group 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 238000000275 quality assurance Methods 0.000 description 1
- 230000000284 resting effect Effects 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000013024 troubleshooting Methods 0.000 description 1
Landscapes
- Debugging And Monitoring (AREA)
- Medical Treatment And Welfare Office Work (AREA)
Abstract
The invention provides a method and device for selectively recovering test execution. The method and device can change execution of progresses dynamically. The method includes the steps that a host progress receives an operation request of a user; the host progress sets an operation variable value in a host progress structure body in a shared memory to be a value representing the operation request, and then notification signals are transmitted to sub-progresses; after receiving the notification signals, the sub-progresses judge the operation variable value in the host progress structure body in the shared memory and execute corresponding operation. Based on the multiple progresses and multiple threads, through the method and device, the operation variable value in the host progress structure body is changed to dynamically change execution of the progresses according to the operation request of the user, execution states of all the progresses are controlled, switching between several progress states is achieved, in this way, test scenes can be enriched, and a complex test curvature can be manufactured accordingly.
Description
The patent application of the invention is a divisional application of Chinese patent application with the application date of 2011, 6 and 17, the application number of 201110163953.6 and the name of 'a scheduling method and device for test execution'.
Technical Field
The present application relates to testing technologies, and in particular, to a method and an apparatus for selectively resuming test execution in a performance test.
Background
The software testing is to utilize a testing tool to perform function and performance testing on a product according to a testing scheme and a flow, even to compile different testing tools according to needs, design and maintain a testing system, and analyze and evaluate possible problems of the testing scheme. After the test case is executed, the failure needs to be tracked to ensure that the developed product meets the requirements.
The performance test in the software test is to simulate various normal, peak and abnormal load conditions through an automatic test tool to test various performance indexes of the system. The performance tests include concurrent performance tests, fatigue strength tests, large data volume tests, speed tests and the like, wherein the concurrent performance tests are important.
The concurrent performance testing process is a process of load testing and pressure testing, namely, a process of gradually increasing the load until the bottleneck of the system or the performance point which can not be received, and determining the concurrent performance of the system by comprehensively analyzing the transaction execution index and the resource monitoring index.
Currently, in concurrent performance testing, the scheduling of concurrent requests is fixed at the beginning of performance testing, and after a user inputs the number of concurrencies to be generated, the system generates concurrencies according to the fixed value. In practical applications, however, there are many different situations in a system, for example, a system requires the number of concurrencies for testing to reach the bottom of a valley at zero night, and requires the number of concurrencies to reach two peak periods at nine am and twelve am, but the generation of the number of concurrencies in the whole testing process is fixed by the scheduling method, and the testing situation of the system cannot be simulated.
Therefore, in the existing concurrent performance test, the above concurrent scheduling method cannot simulate a complex test scenario, so that the test result is not enough to explain the problems encountered by the test scenario, and may even cause the test to have problems.
Disclosure of Invention
The application provides a method and a device for selectively recovering test execution, which are used for solving the problem of fixed concurrency number in a test.
The embodiment of the application discloses a method for selectively recovering test execution, which comprises the following steps:
the main process receives an operation request;
when the operation request is a request for selectively restoring the execution of the partial subprocess, the main process sets the value of the operation variable in the main process structure body in the shared memory to represent the value for selectively restoring the execution of the partial subprocess, and sends a notification signal to the selectively restored subprocess;
the selected and recovered subprocess sets the operation variable value in the subprocess structure body in the shared memory as a value representing continuous execution according to the operation variable value representing the execution of the selectively recovered subprocess;
and selecting the sub-thread of the recovered sub-process, and executing the current test operation according to the operation variable value representing the continuous execution in the sub-process structure body in the shared memory before the circular execution test.
Preferably, the step of sending a notification signal to the child process that selects recovery comprises:
the main process traverses each subprocess structural body in the shared memory, judges whether the subprocess is suspended according to the variable value of the operation in the subprocess structural body, and returns the subprocess identification of suspended execution;
the main process receives a sub-process identifier selected to be recovered from the sub-process identifiers of the suspended execution;
and the main process sends a notification signal to the sub-process corresponding to the sub-process identification selected to be recovered.
Preferably, the method further comprises:
when the operation request is a request for executing the forced quit test, the main process sets the operation variable value in the main process structure body in the shared memory as a value representing the forced quit test, and sends a notification signal to the sub-process;
and the subprocess quits the process operation according to the operation variable value representing the forced quit test in the subprocess structure belonging to the shared memory.
Preferably, the method further comprises:
when the operation request is a request for stopping the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory as a value representing the stop of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
setting the operation variable value in the subprocess structure body in the shared memory as a value representing stopping execution by the subprocess according to the operation variable value representing stopping execution of all the subprocesses;
before the sub-thread of the sub-process circularly executes the test, the circular test operation is quitted according to the operation variable value representing the stop of the execution in the sub-process structure body which belongs to the shared memory;
and the subprocess generates a test report according to the test data.
Preferably, the method further comprises:
when the operation request is a request for suspending the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory to a value representing the suspension of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
setting the operation variable value in the sub-process structure body in the shared memory to represent the value of suspended execution by the sub-process according to the operation variable value representing the suspended execution of all the sub-processes;
before the sub-thread of the sub-process circularly executes the test, the current test operation is stopped to jump into the next test operation according to the operation variable value representing the suspended execution in the sub-process structure body in the shared memory.
Preferably, the method further comprises:
when the operation request is a request for recovering the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory as a value representing the recovery of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
the subprocess sets the operation variable value in the subprocess structure body in the shared memory as a value representing the continuous execution according to the operation variable value representing the recovery of all subprocesses;
before the sub-thread of the sub-process circularly executes the test, the test operation is continuously executed according to the operation variable value representing the continuous execution in the sub-process structure body which belongs to the shared memory.
Preferably, the method further comprises:
when the operation request is a request for executing the selective pause part of the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory to a value representing the execution of the selective pause part of the subprocesses, and sends a notification signal to the selective pause part of the subprocesses;
the selected suspended subprocess sets the operation variable value in the subprocess structure body in the shared memory as the value representing the suspended execution according to the operation variable value representing the execution of the selectively suspended subprocess;
and before the sub-thread of the suspended sub-process circularly executes the test, stopping executing the current test operation according to the operation variable value representing the suspended execution in the sub-process structure body in the shared memory so as to jump into the next test operation.
Preferably, the step of sending a notification signal to the selected suspended sub-process comprises:
the main process traverses each subprocess structural body in the shared memory, judges whether the subprocess is executed according to the variable value of the operation in the subprocess structural body, and returns the subprocess identification which is executed;
the main process receives a sub-process identification which is selected to be suspended from the sub-process identifications in execution;
and the main process sends a notification signal to the sub-process corresponding to the sub-process identifier selected to be suspended.
Preferably, before the host process receives the operation request, the method further includes:
the main process receives the scheduling control signal and returns to the operation menu;
and the main process receives the operation options selected in the operation menu, wherein each operation option in the operation menu corresponds to an operation request.
The embodiment of the application also discloses a device for selectively recovering test execution, which comprises a main process, a sub-process and a sub-thread; wherein,
the main process comprises the following steps:
an operation request receiving module, configured to receive an operation request;
the first main scheduling module is used for setting the value of the operation variable in the main process structure body in the shared memory as a value representing the execution of the selective recovery part subprocess and sending a notification signal to the selective recovery subprocess when the operation request is the request of the selective recovery part subprocess;
selecting a child process for recovery includes:
the selective recovery module is used for setting the operation variable value in the sub-process structure body in the shared memory as a value representing continuous execution according to the operation variable value representing the selective recovery part of the sub-process execution;
selecting child threads of the recovered child process includes:
and the selective recovery testing module is used for executing the current testing operation according to the operation variable values representing the continuous execution in the subprocess structure body which belongs to the shared memory before the circular execution testing.
Preferably, the first master scheduling module comprises:
the first subprocess identification returning submodule is used for traversing each subprocess structural body in the shared memory, judging whether the subprocess is suspended according to the operation variable value in the subprocess structural body, and returning the subprocess identification of suspended execution;
the first sub-process identification receiving sub-module is used for receiving a sub-process identification selected to be recovered from the sub-process identifications suspended from execution;
and the first notification signal sending sub-module is used for sending a notification signal to the sub-process corresponding to the sub-process identifier selected to be recovered. Preferably, the main process further comprises:
the second master scheduling module is used for setting the operation variable value in the master process structure body in the shared memory to a value representing the forced quit test and sending a notification signal to the child process when the operation request is the request for executing the forced quit test;
the sub-process further comprises:
and the forced exit module is used for exiting the process operation according to the operation variable value representing the forced exit test in the subprocess structure body in the shared memory.
Preferably, the main process further comprises:
the third main scheduling module is used for setting the value of the operation variable in the main process structure body in the shared memory as a value representing stopping all the subprocesses from executing when the operation request is a request for stopping all the subprocesses from executing, and sending a notification signal to the subprocesses;
the sub-process further comprises:
the stopping module is used for setting the operation variable value in the subprocess structure body in the shared memory as a value representing stopping execution according to the operation variable value representing stopping execution of all the subprocesses;
and the test report generating module is used for generating a test report according to the test data.
The child threads of the child process further include:
and the stop test module is used for exiting the loop test operation according to the operation variable value representing the stop of the execution in the subprocess structure body in the shared memory before the loop execution test.
Preferably, the main process further comprises:
the fourth main scheduling module is used for setting the operation variable value in the main process structure body in the shared memory to a value representing that all the subprocesses are suspended to execute when the operation request is a request for suspending all the subprocesses to execute, and sending a notification signal to the subprocesses;
the sub-process further comprises:
the pause module is used for setting the operation variable value in the subprocess structure body in the shared memory as the value representing the pause execution according to the operation variable value representing the pause execution of all the subprocesses;
the child threads of the child process further include:
and the pause testing module is used for stopping executing the current testing operation according to the operation variable value representing the pause execution in the subprocess structure body in the shared memory before the test is executed circularly so as to jump to the next testing operation.
Preferably, the main process further comprises:
the fifth main scheduling module is used for setting the operation variable value in the main process structure body in the shared memory as a value representing the recovery of all the subprocesses to execute when the operation request is a request for recovering the execution of all the subprocesses, and sending a notification signal to the subprocesses;
the sub-process further comprises:
the recovery module is used for setting the operation variable values in the sub-process structure body in the shared memory as values representing continuous execution according to the operation variable values representing the recovery of all the sub-processes;
the child threads of the child process further include:
and the continuous testing module is used for continuously executing the testing operation according to the operation variable values representing continuous execution in the subprocess structure body which belongs to the shared memory before the circular execution testing.
Preferably, the main process further comprises:
the sixth main scheduling module is used for setting the value of the operation variable in the main process structure body in the shared memory to be a value representing the execution of the selective pause part subprocess and sending a notification signal to the selective pause part subprocess when the operation request is the request of the selective pause part subprocess;
selecting the suspended sub-process further comprises:
the selective pause module is used for setting the value of the operation variable in the subprocess structure body in the shared memory as the value representing the pause execution according to the value of the operation variable representing the selective pause part of the subprocess execution;
selecting a child thread of the suspended child process further comprises:
and the selective pause test module stops executing the current test operation according to the operation variable value representing the pause execution in the subprocess structure body in the shared memory before the test is executed circularly so as to jump into the next test operation.
Preferably, the sixth master scheduling module includes:
the second subprocess identification returning submodule is used for traversing each subprocess structural body in the shared memory, judging whether the subprocess is executed according to the operation variable value in the subprocess structural body, and returning the subprocess identification which is executed;
a second sub-process identification receiving sub-module, configured to receive a sub-process identification selected to be suspended from the currently executed sub-process identifications;
and the second notification signal sending sub-module is used for sending a notification signal to the sub-process corresponding to the sub-process identifier selected to be suspended.
Preferably, the main process further comprises:
the operation menu returning module is used for receiving the scheduling control signal and returning to the operation menu;
and the operation option receiving module is used for receiving the operation options selected in the operation menu, and each operation option in the operation menu corresponds to one operation request.
The embodiment of the application has the following advantages:
firstly, the embodiment of the application provides a scheduling method for test execution based on multi-process and multi-thread, in the process of performance test, a main process receives an operation request of a user, then sets an operation variable value in a main process structure body in a shared memory as a value representing the operation request, then sends a notification signal to a sub-process, and after the sub-process receives the notification signal, corresponding operation is executed by judging the operation variable value in the main process structure body in the shared memory. By the method, the execution state of each group of processes can be controlled by changing the operation variable value in the main process structure body and dynamically changing the execution of the processes according to the operation request of a user, so that the conversion among several process states is realized, the test scenes can be enriched, and correspondingly, complex test curves can be manufactured.
In addition, in the embodiment of the present application, when the main process sends the notification signal to the sub-process, the same kind of signal is sent regardless of the operation request, because the signal plays a role of notifying the sub-process and does not represent a specific operation request, the amount of usable signals can be saved by using one kind of information, and the method is not limited by the amount of the signals of the operating system, and is suitable for being applied to various actual systems.
Secondly, the method and the device can also realize the interaction between the user and the process, when the user wants to change the process due to certain requirements, the user can send a signal to the main process, and the process to be changed is selected through the feedback of the main process. Therefore, the user and the process have an interactive process, so that the execution state of the processes can be changed, the strategy and the frequency generated by the processes can be adjusted, and various requirements of the user can be met.
Thirdly, the performance problem of the tested system can be checked under the condition that the test execution process is not interrupted. For example, in the pressure test execution process, a memory overflow condition of the tested system is found at a certain moment, the generation of the pressure can be suspended, then developers can check the overflow problem, whether the overflow is continued or not is observed when the pressure is suspended, the pressure is reduced or increased through continuous recovery and suspension, and the checking of the problems of the tested system is completed under the condition that the whole performance test execution process is not interrupted.
Of course, it is not necessary for any product to achieve all of the above-described advantages at the same time for practicing the present application.
Drawings
FIG. 1 is a flow chart of a method of selectively resuming test execution in accordance with an embodiment of the present application;
FIG. 2 is a flow chart of a method of selectively resuming test execution in accordance with a preferred embodiment of the present application;
FIG. 3 is a flowchart of a host process in a method for selectively resuming test execution in accordance with a preferred embodiment of the present application;
FIG. 4 is a flow diagram of a sub-process in a method of selectively resuming test execution in accordance with a preferred embodiment of the present application;
FIG. 5 is a flow diagram of a child thread in a method of selective recovery test execution in accordance with a preferred embodiment of the present application;
FIG. 6 is a block diagram of an apparatus for selectively resuming test execution according to an embodiment of the present application;
fig. 7 is a block diagram of another apparatus for selectively resuming test execution according to an embodiment of the present application.
Detailed Description
In order to make the aforementioned objects, features and advantages of the present application more comprehensible, the present application is described in further detail with reference to the accompanying drawings and the detailed description.
In order to dynamically change the concurrency number in the test process, the application provides a scheduling method for test execution, which is used for dynamically changing the execution of the process and controlling the execution state of each group of processes through the interaction between a user and the process in the performance test process. The method is mainly suitable for various concurrent performance tests.
The contents of the present application will be described in detail below with reference to examples.
Referring to fig. 1, a flowchart of a method for selectively resuming execution of a test according to an embodiment of the present application is shown.
In this embodiment, a multi-process and multi-thread execution process is used, where the multi-process and multi-thread refers to that when concurrent operations are executed, a main process generates multiple sub-processes, and each sub-process generates multiple sub-threads. In addition, in the process of initializing the main process, a process shared memory area is generated, and in the process of executing the test, all processes and sub-threads thereof can access the shared memory area and read variables from the shared memory area.
The method is mainly used for dynamically changing the execution of the process in the test execution process, and comprises the following steps:
step 101, a main process receives an operation request;
in the execution process of the performance test, interaction between a user and a process can be realized, and a main process can receive an operation request of the user in a certain mode.
In this embodiment, a preferable mode is that, when the performance testing system is executed, if a user wants to perform a certain operation, a signal may be sent to the host process, after receiving the signal, the host process returns to an operable menu, and the user selects a certain operation option in the menu and inputs the operation option to the host process. Since each operation option corresponds to one operation request, the user selects a certain operation option and inputs the operation option to the host process, namely, the operation option corresponds to sending one operation request to the host process. Therefore, the user can select corresponding operation according to the requirement of the user to control the test state.
102, the main process sets the value of the operation variable in the main process structure body in the shared memory as the value representing the operation request, and sends a notification signal to the sub-process;
after receiving the operation request, the main process sets the value of the operation variable in the main process structure in the shared memory to a value representing the operation request, and then sends a notification signal to the sub-process being executed.
In this embodiment, a preferable mode is that, when receiving the option operation, the main process assigns a value representing the operation request to an operation variable located in a main process structure in the shared memory, and then sends a signal to each sub-process that is executing the test. Therefore, the execution of the process can be dynamically changed, and the execution state of the process is controlled.
And 103, after receiving the notification signal, the sub-process executes corresponding operation by judging the operation variable value in the main process structure in the shared memory.
After receiving the signal, each sub-process executing the test checks an operation variable in the main process structure in the shared memory, and determines what operation is executed by judging the value of the operation variable, such as process exit, process pause, process resume, and the like.
In summary, in the method described in the embodiment of fig. 1, in the multi-process and multi-thread test execution process, the main process receives an operation request from a user, then sets an operation variable value in the main process structure in the shared memory to a value representing the operation request, and sends a notification signal to the sub-process, and after receiving the notification signal, the sub-process executes a corresponding operation by determining the operation variable value in the main process structure in the shared memory. By the method, the execution state of each group of processes can be controlled by changing the operation variable value in the main process structure body and dynamically changing the execution of the processes according to the operation request of a user, so that the conversion among several process states is realized, the test scenes can be enriched, and correspondingly, complex test curves can be manufactured.
Moreover, when the main process sends the notification signal to the sub-process, the same kind of signal is sent no matter what kind of operation request, because the signal plays a role of notifying the sub-process and does not represent a specific kind of operation request, the usable signal quantity can be saved by using one kind of information, and the method is not limited by the signal quantity of the operation system, and is suitable for being applied to various actual systems.
In practical application, performance testing plays an important role in quality assurance of software, and the content of the test included in the performance testing is rich and diverse. The performance test includes three aspects: the application is used for testing the performance of the client, the performance of the application on the network and the performance of the application at the server. In general, the three aspects are effectively and reasonably combined, and comprehensive analysis and bottleneck prediction of system performance can be achieved.
The server performance test is different from a UI performance test, a client performance test and the like, and the server is accessed by generating a large number of concurrent access requests with high request frequency and high request frequency, so that the server runs under the condition of long-time high load, and the running correctness and stability of the system are checked.
In the performance test of the server, the load test and the pressure test belong to performance tests, and the two tests can be combined. The performance of the system under various working loads is determined through load tests, and the aim is to test the change of various performance indexes of the system when the load is gradually increased. Stress testing is a test that achieves the maximum level of service that a system can provide by determining the bottleneck or unacceptable performance point of a system.
In order to further understand the content of the present application, the following description will take the pressure test of the server as an example.
Taking the Xnix system (Unix and Linux systems, and their derivatives) as an example, the method is also applicable to other operating systems such as Windows.
In the following, a preferred embodiment of the present application is provided, in which a performance testing system of the Xnix system performs stress testing, a stress scheduling method that the testing system and a user can interact with each other.
Firstly, determining an interaction mode of a test system and a user:
in an embodiment of the present application, the method may include the following steps:
104, the main process receives the scheduling control signal and returns to the operation menu;
and 105, receiving the operation options selected in the operation menu by the main process, wherein each operation option in the operation menu corresponds to an operation request.
Before the main process receives an operation request of a user, the main process receives a scheduling control signal sent by the user and returns an operation menu to the user, the user selects operation options in the operation menu and sends the operation options to the main process, and each operation option in the operation menu corresponds to one operation request.
When the performance testing system is executed, if a user wants to perform operations of forcibly exiting the test, stopping the test, suspending all test pressure, recovering all test pressure, suspending part of test pressure or recovering part of test pressure, the user can send a certain signal (for example, the system adopts a signal, namely Ctrl + C) to the main process, after receiving the signal, the main process returns to the user an operable menu, the user selects a certain operation option in the menu and inputs the operation option to the main process, and the main process operates according to the option to achieve the effect of controlling the sub-process.
Second, the signal and shared memory structures together determine the operations to be performed:
when a user sends an operation request to a main process, the main process assigns a value representing the operation request to a childsigopt element of a main process structure body bench located in a shared memory, and sends a certain signal (for example, the system adopts a SIGUSR1 signal) to each sub-process which is executing a stress test, after receiving the signal, a semaphore processing function of a subsystem checks the childsigopt element of the main process structure body bench in the shared memory, and determines what operation to execute by judging the value of the element. For example, the sub-process sets the value of the operation variable within the sub-process structure in shared memory to a value representing the operation request.
In the multi-process and multi-thread test execution process described in the embodiments, each sub-thread of a sub-process cyclically executes a test code, and before each cyclic execution of the sub-thread, the sub-thread executes a corresponding operation by judging an operation variable value in a sub-process structure body to which the sub-thread belongs in a shared memory. For example, the pressure test service logic function executed in each sub-thread of each sub-process is placed in a loop code body, and before each execution, the state of a switch of an element located in the process shared memory and belonging to the branch _ child of the sub-process is determined, where the element has three states:
content ue: the state is a running state and a default state, and the values of the switch elements are the states during running or after running is recovered;
ii.BREAK: a stop state in which, when the value of the switcher is the state, the next cycle jumps out of the cycle body, thereby stopping the pressure generation for performing the performance test;
susound: and a pause state, when the value of the switcher is the state, the loop does not execute, and the next loop is jumped.
The main process informs the sub-process of the request processing through a signal after receiving an operation request sent by a user, and the sub-process determines the value of the switch element of the branch _ child of the process structure by judging the child signature element of the main process structure. And before the next execution of the pressure test service logic function in each sub-thread loop of the sub-process, judging the switch element to determine whether to continue the execution or not, or not to directly enter the next loop or directly exit the process. The main process may control the performance of the stress test on all or a portion of the sub-processes by sending a signal to each sub-process or a portion of the sub-processes.
In this embodiment, the user-selectable operation options include:
1) forcibly exiting;
in an embodiment of the present application, the method may include the following steps:
step S11, when the operation request is the request of forced quit test execution, the main process sets the operation variable value in the main process structure body in the shared memory as the value representing the forced quit test, and sends the notice signal to the sub-process;
in step S12, the sub-process exits the process operation according to the operation variable value representing the forced exit test in the sub-process structure belonging to the shared memory.
The user does not want the test to continue to be executed for some reason and does not need the executed test result, and expects to quit immediately, the user can inform the main process through the interaction mode and requires to quit the performance test system forcibly.
And when the operation request of the user is a request for forcibly quitting the test execution, the corresponding operation executed by the sub-process is a process quitting operation.
For example, after receiving the request, the host process sets the child sigopt element of the host process structure in the shared memory, sets the value of the child sigopt element to 0, and then sends SIGUSR1 signals to each executing child process. And after receiving the signal, the sub-process judges whether the child sigopt element of the main process structure in the shared memory is 0, and if so, executes exit process (exit) operation.
2) Stopping all tests;
in an embodiment of the present application, the method may include the following steps:
step S21, when the operation request is a request for stopping the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory as a value representing the stop of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
step S22, the subprocess sets the operation variable value in the subprocess structure in the shared memory as the value representing stopping the execution according to the operation variable value representing stopping the execution of all the subprocesses;
step S23, before the sub-thread of the sub-process circularly executes the test, the circular test operation is quitted according to the operation variable value representing the stop of the execution in the sub-process structure body which belongs to the shared memory;
in step S24, the sub-process generates a test report based on the test data.
The user for some reason wishes to end the test and give a test report immediately (e.g. after the performance test has run for several hours, the required data can be analyzed based on the test procedure up to now), the main process can be informed by said interaction means, the performance test stress generation is required to be stopped,
when the operation request of the user is a request for stopping the execution of all the subprocesses, each subprocess sets the value of the operation variable in the subprocess structure body in the shared memory as a value representing the stop of the execution, and when each subprocess of each subprocess is executed to the next cycle, judges that the value of the operation variable in the subprocess structure body in the shared memory is set as a value representing the stop of the execution, and exits the cycle operation. And each subprocess waits until each subprogram of the subprogram exits the loop operation, analyzes the test data of the subprogram and generates a test report.
For example, after receiving the request, the host process sets the child sigopt element of the host process structure in the shared memory, sets the value of the child sigopt element to 1, and then sends SIGUSR1 signals to each executing child process. And after receiving the signal, the sub-process judges whether the child sigopt element of the main process structure in the shared memory is 1, if so, finds the branch _ child structure belonging to the process in the process shared memory, and assigns a switch element of the structure to BREAK. When the loop body of each sub-thread in each sub-process is executed to the next loop, judging that the switch element value of the bench _ child structure body is BREAK, executing a jump loop operation (BREAK), and then after the sub-process waits until each sub-thread exits, executing the work of analyzing the performance test data of the process to generate a performance test report.
3) Pausing all tests;
in an embodiment of the present application, the method may include the following steps:
step S31, when the operation request is a request for suspending the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory as a value representing the suspension of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
step S32, the child process sets the value of the operation variable in the child process structure in the shared memory to the value representing the suspended execution according to the value of the operation variable representing the suspended execution of all child processes;
in step S33, before the sub-thread of the sub-process performs the loop test, the current test operation is stopped according to the value of the operation variable representing the suspended execution in the sub-process structure in the shared memory, so as to jump to the next test operation.
If the user wants to pause the test for some reason (for example, the current pressed system finds out the performance abnormality and needs to stop the pressure for debugging and analyzing), the user can inform the main process in the interactive mode to pause the generation of the performance test pressure.
When the operation request of the user is a request for suspending the execution of all the subprocesses, each subprocess sets the value of the operation variable in the subprocess structure body in the shared memory as a value representing the suspended execution, and when each subprocess of each subprocess is executed to the next cycle, judges that the value of the operation variable in the subprocess structure body in the shared memory is set as the value representing the suspended execution, the cycle operation is stopped and the next cycle is jumped in.
For example, after receiving the request, the host process sets the child sigopt element of the host process structure in the shared memory, sets the value of the child sigopt element to 2, and then sends SIGUSR1 signals to each executing child process. And after receiving the signal, the sub-process judges whether the child sigopt element of the main process structure body in the shared memory is 2, if so, finds the branch _ child structure body belonging to the process in the process shared memory, and assigns a suspectr element of the structure body to be SUSPEND. And when the loop body of each sub-thread in each sub-process is executed to the next loop, judging that the switch element value of the bench _ child structure is SUSPEND, not executing any pressure test business logic function, and after a rest for a plurality of milliseconds, entering the next loop until the switch element value of the bench _ child structure is changed into other states.
4) All tests are resumed;
in an embodiment of the present application, the method may include the following steps:
step S41, when the operation request is a request for recovering the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory as a value representing the recovery of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
step S42, the child process sets the operation variable value in the child process structure in the shared memory to represent the value of continuing execution according to the operation variable value representing the recovery of all child process executions;
in step S43, before the sub-thread of the sub-process performs the loop test, the sub-thread continues to perform the test operation according to the value of the operation variable representing the continued execution in the sub-process structure body belonging to the shared memory.
After the pressure generation of all processes in the performance test is suspended, if a user wants to resume the test for some reason, the user can inform the main process in the interactive mode to request to resume the pressure generation of the performance test.
When the operation request of the user is a request for recovering the execution of all the subprocesses, each subprocess sets the value of the operation variable in the subprocess structure body in the shared memory as a value representing the continuous execution, and when each subprocess of each subprocess executes to the next cycle, the value of the operation variable in the subprocess structure body in the shared memory is judged to be set as the value representing the continuous execution, and the cycle operation is continuously executed.
For example, after receiving the request, the host process sets the child sigopt element of the host process structure in the shared memory, sets the value of the child sigopt element to 3, and then sends SIGUSR1 signals to each executing child process. And after receiving the signal, the sub-process judges whether the child signature element of the main process structure in the shared memory is 3, if so, finds the branch _ child structure belonging to the process in the process shared memory, and assigns a switch element of the structure to CONTINUE. And when the loop body of each sub-thread in each sub-process is executed to the next loop, judging that the value of the switcher element of the bench _ child structure body is CONTINUE, and continuing to execute the pressure test business logic function so as to recover the generation of the pressure.
5) Pausing the partial test;
in an embodiment of the present application, the method may include the following steps:
step S51, when the operation request is the request of selectively suspending partial subprocess execution, the main process sets the value of the operation variable in the main process structure in the shared memory as the value representing the selectively suspending partial subprocess execution, and sends the notice signal to the selectively suspending subprocess;
step S52, the suspended sub-process sets the value of the operation variable in the sub-process structure in the shared memory to the value representing the suspended execution according to the value of the operation variable representing the selectively suspended sub-process;
step S53, before the sub-thread of the suspended sub-process is selected to perform the loop test, the current test operation is stopped according to the value of the operation variable representing the suspended execution in the sub-process structure in the shared memory, so as to jump to the next test operation.
If the user wants to simulate the behavior of real user access under a certain environment by changing the size of the pressure concurrency for some reason (for example, the concurrent access pressure of a certain master station WEB server is very high from 6 pm to 9 pm, and the quantity of the concurrent requests is gradually reduced after 10 pm), the main process can be informed in the interactive mode, and the performance test pressure generation of certain processes is required to be suspended.
When the operation request of the user is a request for selectively suspending the execution of part of the subprocesses, the main process traverses each subprocess structural body in the shared memory, judges whether the subprocess is executed according to the value of the operation variable in the subprocess structural body, and sends the executed subprocess identification to the user; then, the main process receives the sub-process identification selected to be suspended by the user, sets the operation variable value in the main process structure body in the shared memory to be a value representing the execution of the sub-process of the selective suspension part, and then sends a notification signal to the sub-process selected to be suspended by the user; after the sub-process selected by the user to be suspended receives the notification signal, setting the value of the operation variable in the sub-process structure in the shared memory as a value representing suspended execution; and when the user selects each sub-thread of the suspended sub-process to execute to the next loop, judging that the value of the operation variable in the sub-process structure body which belongs to the shared memory is set to be the value representing the suspended execution, stopping executing the loop operation, and jumping into the next loop.
In a preferred example of the embodiment of the present application, step S51 may include the following sub-steps:
substep S51-1, the main process traverses each subprocess structure in the shared memory, judges whether the subprocess is executing according to the operation variable value in the subprocess structure, and returns the subprocess identification which is executing;
sub-step S51-2, the main process receiving a selection of a suspended sub-process identification from the executing sub-process identifications;
in sub-step S51-3, the main process sends a notification signal to the sub-process corresponding to the sub-process identification selected for suspension.
For example, the main process determines whether the state of the switch element of the process structure is running, namely CONTINUE, by traversing the bench _ child structure of each sub-process in the shared memory, and sends the process identification PIDs of the sub-processes in the running state to the user, so that the user can select. And the user sends the process PID needing to be suspended to the main process, the main process sets the child sigopt element of the main process structure in the shared memory after receiving the request, the value of the child sigapt element is set to be 4, and then SIGUSR1 signals are sent to a plurality of child processes appointed by the user. After receiving the signal, the sub-processes judge whether the child sigopt element of the main process structure in the shared memory is 4, if so, find the branch _ child structure belonging to the process in the process shared memory, and assign the switch element of the structure to SUSPEND. When the loop body of each sub-thread of the batch of sub-processes is executed to the next loop, judging that the switch element value of the bench _ child structure of the process is SUSPEND, not executing any pressure test business logic function, and after resting for a plurality of milliseconds, entering the next loop until the switch element value of the bench _ child structure is changed into other states.
6) And (6) recovering part of the test.
In an embodiment of the present application, the method may include the following steps:
step S61, when the operation request is the request for selectively restoring the partial sub-process, the main process sets the value of the operation variable in the main process structure in the shared memory to the value representing the execution of the partial sub-process, and sends the notification signal to the sub-process selected for restoring;
step S62, the selected and restored sub-process sets the value of the operation variable in the sub-process structure in the shared memory to a value representing continued execution according to the value of the operation variable representing the execution of the selectively restored sub-process;
step S63, before the sub-thread of the recovered sub-process is selected to perform the loop test, the current test operation is performed according to the value of the operation variable representing the continued execution in the sub-process structure body in the shared memory.
After some performance test processes are suspended, if a user wants to resume the stress test execution of some suspended processes for some reason, the user can inform the main process through the interactive mode to request to resume the performance test stress generation of some processes.
When the operation request of the user is a request for selectively recovering the execution of part of the subprocesses, the main process traverses each subprocess structural body in the shared memory, judges whether the subprocess suspends the execution or not according to the value of the operation variable in the subprocess structural body, and sends the subprocess identifier which suspends the execution to the user. Then, the main process receives the sub-process identification selected by the user for recovery, sets the operation variable value in the main process structure body in the shared memory to the value representing the execution of the selective recovery part of the sub-process, and then sends a notification signal to the sub-process selected by the user. And then after the sub-process selected by the user to be recovered receives the notification signal, setting the value of the operation variable in the sub-process structure in the shared memory as a value representing continuous execution. And when the user selects each sub-thread of the recovered sub-process to execute the next cycle, judging that the value of the operation variable in the sub-process structure body belonging to the shared memory is set as a value representing the continuous execution, and continuously executing the cycle operation.
In a preferred example of the embodiment of the present application, step S61 may include the following sub-steps:
in substep 61-1, the main process traverses each subprocess structure in the shared memory, judges whether the subprocess is suspended according to the operation variable value in the subprocess structure, and returns the subprocess identifier for suspended execution;
sub-step 61-2, the main process receiving the sub-process identification selected for recovery from the suspended sub-process identification;
and a sub-step 61-3, in which the main process sends a notification signal to the sub-process corresponding to the sub-process identifier selected for recovery.
For example, the main process determines whether the state of the switcher element of the process structure is paused, that is, SUSPEND, by traversing the bench _ child structure of each sub-process in the shared memory, and sends the process PIDs of the sub-processes in the paused state to the user, so that the user can select the sub-processes. And the user sends the process PID which needs to be recovered to the main process, the main process sets the child sigopt element of the main process structure in the shared memory after receiving the request, the value of the child sigopt element is set to be 5, and then SIGUSR1 signals are sent to a plurality of child processes appointed by the user. And after receiving the signal, the sub-processes judge whether the child sigopt element of the main process structure in the shared memory is 5, if so, find the branch _ child structure belonging to the process in the process shared memory, and assign the switch element of the structure to CONTINUE. When the loop body of each sub-thread of the batch of sub-processes is executed to the next loop, and the value of the switcher element of the bench _ child structure body of the process is judged to be CONTINUE, the business logic function of the pressure test is continuously executed, so that the tested system obtains larger concurrent pressure.
In summary, the present embodiment may also implement interaction between the user and the process, and when the user wants to change the process due to a certain requirement, the user may send a signal to the host process, and select the process to be changed through the feedback of the host process. Therefore, the user and the process have an interactive process, so that the execution state of the processes can be changed, the strategy and the frequency generated by the processes can be adjusted, and various requirements of the user can be met. Moreover, the process is dynamically changed, the conversion among several process states can be realized, the test scenes of the process are enriched, and correspondingly, a complex pressure curve can be provided.
In addition, in the method described in this embodiment, when the main process sends the notification signal to the sub-process, the same kind of signal is sent regardless of the request, because the signal plays a role of notifying the sub-process and does not represent a specific operation request, and therefore, the amount of usable signals can be saved by using one kind of information, and the method is not limited by the amount of signals of the operating system, and is suitable for being applied to various actual systems.
In addition, the method of this embodiment can troubleshoot the performance problem of the system under test without interrupting the execution process of the test, for example, in the execution process of the pressure performance test, it is found that there is a memory overflow condition in the system under test at a certain time, through the method, the generation of the pressure can be suspended, then developers can troubleshoot the overflow problem, observe whether the overflow continues or shrinks when the pressure is suspended, and through continuous recovery and suspension, reduce and raise the pressure, and under the condition that the execution process of the whole performance test is not interrupted, the troubleshooting of the system under test is completed. Therefore, the utility model has strong practicability.
Based on the above, the flow of a preferred embodiment of the present application is described in detail below with reference to fig. 2 to 5. In the multi-process and multi-thread test execution process, the execution of the process can be dynamically changed, and various requirements of users are met.
The present embodiment takes Xnix system (Unix and Linux systems, and their derivatives) as an example, but the method is also applicable to other operating systems such as Windows.
Referring to fig. 2, a flow chart of a method for selectively resuming test execution according to the preferred embodiment of the present application is shown.
Step 201, starting a pressure test, and registering and receiving SIGINT and SIGURSR 1 signals by a main process;
the signal processing mechanism is as follows: signal (SIGNT, cb _ trap); signal (SIGUSR1, cb _ trap).
Step 202, initializing a process shared memory, initializing a main process structure, allocating space for each subprocess structure, and storing a pointer of the shared memory into a global variable mbp;
including the structure of the main process and the sub-process structure, as shown in the figure.
Step 203, generating a specified number of sub-processes through function fork ();
after step 203, the process may proceed to step 204, or may proceed to flow B, see fig. 5.
Step 204, the main process generates a timer thread, so that the execution times of the Cbenchmark main process can be controlled by time;
if the time is controlled, go to step 205, and if the time is not controlled, wait for all the sub-processes to finish.
Step 205, appointing time and starting timing;
by timing the thread, time is specified by the function pthread _ create ().
And step 206, after the timing is finished, finding a bench structure body of the main process through an mbp variable, assigning a child sigopt element to be 1, and enabling each child process to process through a SIGSR signal.
The main process sends a sigcuri signal to each sub-process, and enters a flow C, see fig. 4.
Referring to fig. 3, a flowchart of a main process in a method for selectively resuming test execution according to a preferred embodiment of the present application is shown.
Step 301, a user sends a Ctrl + C signal to a Cbenchmark main process;
when the performance test system is executed, if a user wants to execute a certain operation, the Ctrl + C signal may be sent to the main process.
Step 302, the main process returns an operable menu to the user;
after receiving the semaphore, the main process returns to the user an operable menu, and the user can input operations including: 0: forced performance test; 1: stopping execution but counting test data; 2: pausing all virtual users; 3: recovering all virtual users; 4: suspending the specified test process; 5: the specified test procedure is resumed.
Step 303, requiring a user to input an operation ID;
and the user determines the operation to be executed according to the requirement of the user and inputs the corresponding operation ID.
Step 304, the user selects the option to be operated and sends the option to the main process;
and the user selects an operand corresponding to the option to be operated, and the main process determines the corresponding option to be operated by determining the operand n.
Step 305, selecting an operand n, and setting a child sigopt element in a bench structure in the shared memory as n;
that is, when the main process receives the option operation, the main process assigns a value representing the operation request to an operation variable located in the main process structure in the shared memory, and then sends a signal to each sub-process executing the test.
Step 306, judging the value of the operand n;
if n is any one of the values 0 to 3, selecting step 307; if n is any of 4 or 5, step 308 is selected.
Step 307, traversing a subprocess linked list in the shared memory, obtaining subprocess pids, and sending a SIGURRI signal to each pid;
the main process sends a sigcuri signal to each sub-process, and enters a flow C, see fig. 4.
Step 308, traversing the switchers of the subprocess structural body in the shared memory, obtaining the current state of the subprocess structural body, and returning the pid in a certain state process to the user for selection;
the host process determines and outputs some of the processes pid.
Step 309, the user selects the designated process to be suspended or resumed;
step 310, a user inputs the selected process pid, and the main process judges whether the input pid is a sub-process pid of the process;
if yes, go to step 311, otherwise, go back to step 308, re-input;
step 311, obtaining the structure bench _ child of the sub-process in the shared memory through the input pid;
step 312, determining whether the state of the switcher element of the child process structure bench _ child is operable;
if yes, go to step 313, otherwise, go back to step 308, re-input;
step 313, the sigsri signal is sent to the child process via the pid.
The main process sends a sigcuri signal to each sub-process, and enters a flow C, see fig. 4.
Referring to fig. 4, a flowchart of a sub-process in a method for selectively resuming test execution according to a preferred embodiment of the present application is shown.
The execution steps of each sub-process are as follows:
step 401, receiving a sigsri signal, and finding a child process structure body and a main process structure body belonging to the process in a shared memory through an mbp pointer;
step 402, judging the value of a child sigopt element of the main process structure body;
step 403, judging whether the child sigopt element of the bench structure body is equal to 0, namely whether to quit forcibly;
if the result is 0, executing exit () to exit the subprocess, and if the result is not 0, executing step 404;
step 404, judging whether the child sigopt element of the bench structure body is equal to 1, namely whether the execution of the process is stopped;
if yes, go to step 405, otherwise go to step 406;
step 405, assigning a value of a siwtcher element of the bench _ child structure of the sub-process to BREAK;
and all the sub-threads of the sub-process exit the loop body in the next loop, then exit operation is executed, and the sub-process waits until each sub-thread exits, and then the sub-process executes the work of analyzing the performance test data of the process so as to generate a performance test report.
Step 406, judging whether the child sigopt element of the bench structure body is equal to 2 or 4, namely whether the process is suspended;
if yes, go to step 407, if no, go to step 408;
step 407, assigning a value of a siwtcher element of the bench _ child structure of the sub-process to SUSPEND;
all the sub-threads of the sub-process do not execute the pressure test function in the next cycle, and directly enter the next cycle.
Step 408, judging whether the child sigopt element of the bench structure body is equal to 3 or 5, namely whether the execution of the process is resumed;
if it is 3 or 5, go to step 409, otherwise, go to 3 or 5, go wrong, and end.
And step 409, assigning a value of the siwtcher element of the bench _ child structure of the sub-process as CONTINUE.
All sub-threads of the sub-process will continue to execute the stress test function on the next cycle.
Referring to FIG. 5, a flow chart of a child process thread in a method for selective recovery test execution in accordance with a preferred embodiment of the present application is shown.
The process includes two parts, which are a sub-process execution process and a sub-thread execution process, respectively, and are described below.
First, each sub-process performs the following steps:
step 501, the sub-process inherits the signal processing mechanism of the main process and obtains a pointer variable mbp of the shared memory;
step 502, finding a subprocess bench _ child structural body belonging to the process in a shared memory through an mbp pointer, initializing, assigning a switcher element as CONTINUE, and indicating that the operation is in progress;
step 503, generating a specified number of threads;
each thread is a concurrent virtual user.
Step 504, waiting for all the sub-threads generated by the process to finish executing;
step 505, judging whether all threads of the process are quitted;
a determination may be made in accordance with step 516, if so, performing step 506, otherwise, returning to performing step 504.
Step 506, collecting and counting test data to generate a test report;
in step 507, execute exit () exits this subroutine.
In step 502 described above, a thread is generated by the function d _ create (), and then step 508 may be entered.
Each sub-thread of each sub-process performs the following steps:
step 508, executing a plurality of threads of a plurality of processes in parallel to generate concurrent pressure;
the thread executes a loop structure, and the structure is executed with a service function of the pressure test;
step 509, determining whether the siwtcher element of the bench _ child structure of the sub-process is CONTINUE;
if so, go to step 510, otherwise, go to step 512.
Step 510, judging whether to execute the specified times;
if yes, go to step 516, otherwise go to step 511.
Step 511, executing a service logic function of the pressure test;
CONTINUE indicates that pressure needs to be executed, so a service logic function of pressure test is executed, and the step 509 is returned;
step 512, judging whether the switch element of the bench _ child structure of the sub-process is SUSPEND;
if yes, go to step 513, otherwise go to step 514;
step 513, not executing the service logic function of the pressure test, and after sleeping for a plurality of times, performing the next cycle;
SUSPEND indicates that the pressure generation needs to be suspended, so the traffic logic function of the pressure test is not performed, and after sleeping for a certain time, the next cycle is performed.
Step 514, judging whether the switch element of the bench _ child structure of the sub-process is BREAK;
if yes, go to step 515; if not, making an error, and ending.
Step 515, directly executing break out loop;
BREAK indicates that the pressure generation needs to be stopped, so here the BREAK jump loop is performed directly.
Step 516, quitting the thread;
after exiting the thread, step 505 may be entered.
From the above, in the performance test, the user can change the state of the process according to the requirement, the main process changes the operation variable value in the main process structure according to the selection of the user, and the sub-process judges the operation variable value in the main process structure and executes the corresponding operation.
In practical application, the method can be realized by C language, and can achieve good effect. Moreover, the method is not dependent on a particular operating system or hardware, and may also be performed across platforms.
The above embodiments are described by taking a pressure test as an example, but the specific application can also be applied to other performance tests, and the implementation principle is similar to the above embodiments, so that the detailed description is omitted.
It should be noted that, for simplicity of description, the above-mentioned method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the present application is not limited by the order of acts described, as some steps may occur in other orders or concurrently depending on the application. Further, those skilled in the art will appreciate that the embodiments described in the specification are presently preferred and that no particular act is required to implement the invention.
Based on the description of the above method embodiment, the present application further provides a corresponding device embodiment for controlling scheduling execution of a test, so as to implement the content described in the above method embodiment.
Fig. 6 is a block diagram of an apparatus for selectively resuming execution of a test according to an embodiment of the present application.
The device can comprise a user interaction unit 61, a main process scheduling unit 62 and a sub process scheduling unit 63. Wherein,
a user interaction unit 61, configured to receive an operation request by a host process;
a main process scheduling unit 62, configured to set an operation variable value in a main process structure in the shared memory to a value representing the operation request by the main process, and send a notification signal to the child process;
and the subprocess scheduling unit 63 is configured to execute a corresponding operation by determining an operation variable value in the main process structure in the shared memory after the subprocess receives the notification signal.
In addition to the above main unit settings, the present apparatus may further include, in accordance with different operation requests:
when the operation request is a request for forced quit of test execution, the sub-process scheduling unit 63 may further include:
and an exit-forcing subunit 631 for the sub-process to exit the process operation.
When the operation request is a request for stopping, suspending or resuming the execution of the sub-process:
the subprocess scheduling unit 63 is configured to set, by the subprocess, an operation variable value in the subprocess structure in the shared memory to a value representing the operation request.
Further, the device further comprises:
a sub-thread scheduling unit 64 for cyclically executing the test code for each sub-thread of the sub-process; before each cycle of execution, the sub-thread executes corresponding operation by judging the operation variable value in the sub-process structure body which belongs to the shared memory.
When the operation request is a request for stopping the execution of all the sub-processes:
the sub-process scheduling unit 63 includes:
a process stop subunit 632 for each sub-process to perform the following respective operations: the subprocess sets the operation variable value in the subprocess structure body in the shared memory as a value representing stopping execution;
and a report generation subunit 633, configured to analyze the test data of the sub-process and generate a test report after the sub-process waits until each sub-thread of the sub-process exits the loop operation.
The child thread scheduling unit 64 includes:
a thread stop subunit 641 for each sub-thread of each sub-process to perform the following respective operations: when the sub-thread executes to the next cycle, judging that the operation variable value in the sub-process structure body which belongs to the shared memory is set to represent the value for stopping executing, and quitting the cycle operation;
when the operation request is a request for suspending the execution of all the sub-processes:
the sub-process scheduling unit 63 includes:
a process halt subunit 634 for each sub-process to perform the following respective operations: the subprocess sets the operation variable value in the subprocess structure body in the shared memory as the value representing the suspended execution;
the child thread scheduling unit 64 includes:
a thread pause subunit 642 for each sub-thread of each sub-process to perform the corresponding operations of: and when the sub-thread executes to the next cycle, judging that the value of the operation variable in the sub-process structure body which belongs to the shared memory is set to be a value representing the suspended execution, stopping executing the cycle operation, and jumping into the next cycle.
When the operation request is a request for recovering the execution of all the child processes:
the sub-process scheduling unit 63 includes:
a process recovery subunit 635 for each sub-process to perform the corresponding operations as follows: the subprocess sets the value of the operation variable in the subprocess structure in the shared memory as the value representing the continuous execution;
the child thread scheduling unit 64 includes:
a thread recovery subunit 643, configured to perform, for each sub-thread of each sub-process, the following respective operations: and when the sub-thread executes to the next cycle, judging that the value of the operation variable in the sub-process structure body which belongs to the shared memory is set to represent the value which is continuously executed, and continuously executing the cycle operation.
When the operation request is a request for selectively suspending execution of a portion of the sub-process:
the user interaction unit 61 is further configured to enable the main process to traverse each subprocess structure in the shared memory, determine whether the subprocess is being executed according to an operation variable value in the subprocess structure, and return an identifier of the subprocess being executed;
the main process scheduling unit 62 is configured to receive, by the main process, the identifier of the sub-process selected to be suspended, set an operation variable value in the main process structure in the shared memory to a value representing execution of the sub-process of the selectively suspended part, and then send a notification signal to the sub-process selected to be suspended;
the sub-process scheduling unit 63 includes:
a process selective pause subunit 636, configured to perform, by the selectively paused subprocess, the following corresponding operations: the subprocess sets the operation variable value in the subprocess structure body in the shared memory as the value representing the suspended execution;
the child thread scheduling unit 64 includes:
a thread selective pause subunit 644 for performing, for each sub-thread of the user-selected paused sub-process, the respective operations of: and when the sub-thread executes to the next cycle, judging that the value of the operation variable in the sub-process structure body which belongs to the shared memory is set to be a value representing the suspended execution, stopping executing the cycle operation, and jumping into the next cycle.
When the operation request is a request for selectively restoring the execution of the partial sub-process:
the user interaction unit 61 is configured to enable the main process to traverse each subprocess structure in the shared memory, determine whether the subprocess suspends execution according to an operation variable value in the subprocess structure, and return to a subprocess identifier for suspending execution;
the main process scheduling unit 62 is configured to receive the identifier of the sub-process selected for recovery by the main process, set an operation variable value in a main process structure in the shared memory to a value representing execution of the sub-process of the selective recovery part, and then send a notification signal to the sub-process selected for recovery;
the sub-process scheduling unit 63 includes:
a process selective recovery sub-unit 637, configured to perform the following corresponding operations for the sub-process selected for recovery: the subprocess sets the value of the operation variable in the subprocess structure in the shared memory as the value representing the continuous execution;
the child thread scheduling unit 64 includes:
a thread selective recovery sub-unit 645 for performing, for each sub-thread of the selectively recovered sub-process, the respective operations of: and when the sub-thread executes to the next cycle, judging that the value of the operation variable in the sub-process structure body which belongs to the shared memory is set to represent the value which is continuously executed, and continuously executing the cycle operation.
Preferably, the user interaction unit 61 is further configured to receive a scheduling control signal sent by the host process before receiving the operation request, return to the operation menu, and receive operation options selected in the operation menu, where each operation option corresponds to one operation request.
The scheduling device for controlling the test can be used in the concurrent test of multiple processes and multiple threads, and can dynamically change the execution of the processes according to the operation request of a user and through the value of the operation variable in the main process structure body and control the execution state of each group of processes.
In addition, since the same kind of signal is transmitted regardless of the operation request when the user transmits the operation request to the host process, the device can save the usable amount of signals, and is not limited to the amount of signals of the operating system, and is suitable for application to various actual systems.
Referring to fig. 7, there is shown an apparatus structure diagram of another selective recovery test execution according to an embodiment of the present application, where the apparatus may include a main process 710, a sub-process 720, and a sub-process 730; wherein,
the host process 710 may include the following modules:
an operation request receiving module 711, configured to receive an operation request;
a first master scheduling module 712, configured to set, when the operation request is a request for selectively recovering execution of a part of the sub-processes, an operation variable value in a master process structure in the shared memory to a value representing execution of the part of the selectively recovering sub-processes, and send a notification signal to the selectively recovered sub-processes;
selecting the resumed sub-process 720 may include the following modules:
the selective recovery module 721 is configured to set, according to the value of the operation variable representing the execution of the selective recovery part of the sub-process, the value of the operation variable in the sub-process structure in the shared memory to a value representing the continued execution;
selecting the child thread 730 of the recovered child process 720 may include the following modules:
the selective recovery testing module 731 is configured to execute the current testing operation according to the value of the operation variable representing the continued execution in the sub-process structure belonging to the shared memory before the loop execution testing.
In a preferred example of the embodiment of the present application, the first master scheduling module 712 may include the following sub-modules:
the first subprocess identification returning submodule is used for traversing each subprocess structural body in the shared memory, judging whether the subprocess is suspended according to the operation variable value in the subprocess structural body, and returning the subprocess identification of suspended execution;
the first sub-process identification receiving sub-module is used for receiving a sub-process identification selected to be recovered from the sub-process identifications suspended from execution;
and the first notification signal sending sub-module is used for sending a notification signal to the sub-process corresponding to the sub-process identifier selected to be recovered.
In a preferred embodiment of the present application, the main process 710 may further include the following modules:
a second master scheduling module 713, configured to set, when the operation request is a request for performing a forced quit test, an operation variable value in a master process structure in the shared memory to a value representing the forced quit test, and send a notification signal to the child process;
sub-process 720 may also include the following modules:
and an exit forcing module 722, configured to exit the process operation according to the operation variable value representing the exit forcing test in the sub-process structure in the shared memory.
In a preferred embodiment of the present application, the main process 710 may further include the following modules:
a third main scheduling module 714, configured to, when the operation request is a request for stopping execution of all the sub-processes, set an operation variable value in the main process structure in the shared memory to a value representing that execution of all the sub-processes is stopped, and send a notification signal to the sub-processes;
sub-process 720 may also include the following modules:
a stopping module 723, configured to set, according to the operation variable value representing that all the sub-processes are stopped from executing, the operation variable value in the sub-process structure in the shared memory to a value representing that execution is stopped;
and a test report generating module 724, configured to generate a test report according to the test data.
Sub-thread 730 of sub-process 720 may also include the following modules:
the stop test module 732 is configured to exit the loop test operation according to the operation variable value representing the stop of the execution in the sub-process structure in the shared memory before the loop execution test.
In a preferred embodiment of the present application, the main process 710 may further include the following modules:
a fourth master scheduling module 715, configured to set, when the operation request is a request for suspending execution of all the child processes, an operation variable value in the master process structure in the shared memory to a value representing that execution of all the child processes is suspended, and send a notification signal to the child processes;
sub-process 720 may also include the following modules:
the suspending module 725 is used for setting the operation variable value in the sub-process structure in the shared memory to the value representing the suspended execution according to the operation variable value representing the suspended execution of all the sub-processes;
sub-thread 730 of sub-process 720 may also include the following modules:
the pause test module 733 is configured to, before the loop execution test, stop executing the current test operation according to an operation variable value representing the pause execution in the sub-process structure belonging to the shared memory, so as to jump to a next test operation.
In a preferred embodiment of the present application, the main process 710 may further include the following modules:
a fifth master scheduling module 716, configured to set, when the operation request is a request for recovering execution of all the child processes, an operation variable value in the master process structure in the shared memory to a value representing recovery of execution of all the child processes, and send a notification signal to the child processes;
sub-process 720 may also include the following modules:
a recovering module 726, configured to set, according to the operation variable value representing the recovery of all the child processes to execute, the operation variable value in the child process structure in the shared memory to a value representing the continued execution;
sub-thread 730 of sub-process 720 may also include the following modules:
the continuing test module 734 is configured to continue to execute the test operation according to the value of the operation variable representing the continued execution in the sub-process structure belonging to the shared memory before the loop execution test.
In a preferred embodiment of the present application, the main process 710 may further include the following modules:
a sixth main scheduling module 717, configured to set, when the operation request is a request for selectively suspending the execution of the partial sub-process, an operation variable value in the main process structure in the shared memory to a value representing the execution of the selectively suspended partial sub-process, and send a notification signal to the selectively suspended sub-process;
selecting the suspended sub-process 720 may also include the following modules:
the selective pause module 727 is used for setting the value of the operation variable in the subprocess structure body in the shared memory as the value representing the pause execution according to the value of the operation variable representing the selective pause part of the subprocess execution;
the child thread 730 that selects the paused child process 720 may also include the following modules:
the selective pause testing module 735 stops executing the current testing operation according to the value of the operation variable representing the pause execution in the sub-process structure belonging to the shared memory before the loop execution testing, so as to jump to the next testing operation.
In a preferred example of the embodiment of the present application, the sixth master scheduling module 717 may include the following sub-modules:
the second subprocess identification returning submodule is used for traversing each subprocess structural body in the shared memory, judging whether the subprocess is executed according to the operation variable value in the subprocess structural body, and returning the subprocess identification which is executed;
a second sub-process identification receiving sub-module, configured to receive a sub-process identification selected to be suspended from the currently executed sub-process identifications;
and the second notification signal sending sub-module is used for sending a notification signal to the sub-process corresponding to the sub-process identifier selected to be suspended.
In a preferred embodiment of the present application, the main process 710 may further include the following modules:
an operation menu returning module 718, configured to receive the scheduling control signal and return to the operation menu;
an operation option receiving module 719, configured to receive operation options selected in the operation menu, where each operation option in the operation menu corresponds to one operation request.
For the above-mentioned embodiment of the apparatus for selective test execution, since it is substantially similar to the embodiment of the method, the description is simple, and the relevant points can be referred to the partial description of the embodiment of the method shown in fig. 1 to 5.
The embodiments in the present specification are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other.
The embodiments in the present specification are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other.
As will be appreciated by one of skill in the art, embodiments of the present application may be provided as a method, apparatus, or computer program product. Accordingly, embodiments of the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, embodiments of the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
In a typical configuration, the computer device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory. The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium. Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include non-transitory computer readable media (fransitory media), such as modulated data signals and carrier waves.
Embodiments of the present application are described with reference to flowchart illustrations and/or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing terminal to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing terminal to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing terminal to cause a series of operational steps to be performed on the computer or other programmable terminal to produce a computer implemented process such that the instructions which execute on the computer or other programmable terminal provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
While preferred embodiments of the present application have been described, additional variations and modifications of these embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including the preferred embodiment and all such alterations and modifications as fall within the true scope of the embodiments of the application.
Finally, it should also be noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or terminal that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or terminal. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or terminal that comprises the element.
The method and apparatus for selectively resuming test execution provided by the present application are introduced in detail above, and a specific example is applied in the description to explain the principle and the implementation of the present application, and the description of the above embodiment is only used to help understand the method and the core idea of the present application; meanwhile, for a person skilled in the art, according to the idea of the present application, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present application.
Claims (11)
1. A method for selectively resuming test execution, comprising:
the main process receives an operation request;
when the operation request is a request for selectively restoring the execution of the partial subprocess, the main process sets the value of the operation variable in the main process structure body in the shared memory to represent the value for selectively restoring the execution of the partial subprocess, and sends a notification signal to the selectively restored subprocess;
the selected and recovered subprocess sets the operation variable value in the subprocess structure body in the shared memory as a value representing continuous execution according to the operation variable value representing the execution of the selectively recovered subprocess;
and selecting the sub-thread of the recovered sub-process, and executing the current test operation according to the operation variable value representing the continuous execution in the sub-process structure body in the shared memory before the circular execution test.
2. The method of claim 1, wherein the step of sending a notification signal to the child process that selected to resume comprises:
the main process traverses each subprocess structural body in the shared memory, judges whether the subprocess is suspended according to the variable value of the operation in the subprocess structural body, and returns the subprocess identification of suspended execution;
the main process receives a sub-process identifier selected to be recovered from the sub-process identifiers of the suspended execution;
and the main process sends a notification signal to the sub-process corresponding to the sub-process identification selected to be recovered.
3. The method of claim 1, further comprising:
when the operation request is a request for executing the forced quit test, the main process sets the operation variable value in the main process structure body in the shared memory as a value representing the forced quit test, and sends a notification signal to the sub-process;
and the subprocess quits the process operation according to the operation variable value representing the forced quit test in the subprocess structure belonging to the shared memory.
4. The method of claim 1, further comprising:
when the operation request is a request for stopping the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory as a value representing the stop of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
setting the operation variable value in the subprocess structure body in the shared memory as a value representing stopping execution by the subprocess according to the operation variable value representing stopping execution of all the subprocesses;
before the sub-thread of the sub-process circularly executes the test, the circular test operation is quitted according to the operation variable value representing the stop of the execution in the sub-process structure body which belongs to the shared memory;
and the subprocess generates a test report according to the test data.
5. The method of claim 1, further comprising:
when the operation request is a request for suspending the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory to a value representing the suspension of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
setting the operation variable value in the sub-process structure body in the shared memory to represent the value of suspended execution by the sub-process according to the operation variable value representing the suspended execution of all the sub-processes;
before the sub-thread of the sub-process circularly executes the test, the current test operation is stopped to jump into the next test operation according to the operation variable value representing the suspended execution in the sub-process structure body in the shared memory.
6. The method of claim 1, further comprising:
when the operation request is a request for recovering the execution of all the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory as a value representing the recovery of the execution of all the subprocesses, and sends a notification signal to the subprocesses;
the subprocess sets the operation variable value in the subprocess structure body in the shared memory as a value representing the continuous execution according to the operation variable value representing the recovery of all subprocesses;
before the sub-thread of the sub-process circularly executes the test, the test operation is continuously executed according to the operation variable value representing the continuous execution in the sub-process structure body which belongs to the shared memory.
7. The method of claim 1, further comprising:
when the operation request is a request for executing the selective pause part of the subprocesses, the main process sets the value of the operation variable in the main process structure body in the shared memory to a value representing the execution of the selective pause part of the subprocesses, and sends a notification signal to the selective pause part of the subprocesses;
the selected suspended subprocess sets the operation variable value in the subprocess structure body in the shared memory as the value representing the suspended execution according to the operation variable value representing the execution of the selectively suspended subprocess;
and before the sub-thread of the suspended sub-process circularly executes the test, stopping executing the current test operation according to the operation variable value representing the suspended execution in the sub-process structure body in the shared memory so as to jump into the next test operation.
8. The method of claim 7, wherein the step of sending a notification signal to the selected suspended sub-process comprises:
the main process traverses each subprocess structural body in the shared memory, judges whether the subprocess is executed according to the variable value of the operation in the subprocess structural body, and returns the subprocess identification which is executed;
the main process receives a sub-process identification which is selected to be suspended from the sub-process identifications in execution;
and the main process sends a notification signal to the sub-process corresponding to the sub-process identifier selected to be suspended.
9. The method of any of claims 1-8, wherein before the host process receives the operation request, the method further comprises:
the main process receives the scheduling control signal and returns to the operation menu;
and the main process receives the operation options selected in the operation menu, wherein each operation option in the operation menu corresponds to an operation request.
10. An apparatus for selectively resuming test execution, the apparatus comprising a main process, a sub thread; wherein,
the main process comprises the following steps:
an operation request receiving module, configured to receive an operation request;
the first main scheduling module is used for setting the value of the operation variable in the main process structure body in the shared memory as a value representing the execution of the selective recovery part subprocess and sending a notification signal to the selective recovery subprocess when the operation request is the request of the selective recovery part subprocess;
selecting a child process for recovery includes:
the selective recovery module is used for setting the operation variable value in the sub-process structure body in the shared memory as a value representing continuous execution according to the operation variable value representing the selective recovery part of the sub-process execution;
selecting child threads of the recovered child process includes:
and the selective recovery testing module is used for executing the current testing operation according to the operation variable values representing the continuous execution in the subprocess structure body which belongs to the shared memory before the circular execution testing.
11. The apparatus of claim 10, wherein the first master scheduling module comprises:
the first subprocess identification returning submodule is used for traversing each subprocess structural body in the shared memory, judging whether the subprocess is suspended according to the operation variable value in the subprocess structural body, and returning the subprocess identification of suspended execution;
the first sub-process identification receiving sub-module is used for receiving a sub-process identification selected to be recovered from the sub-process identifications suspended from execution;
and the first notification signal sending sub-module is used for sending a notification signal to the sub-process corresponding to the sub-process identifier selected to be recovered.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510131327.7A CN104750607B (en) | 2011-06-17 | 2011-06-17 | A kind of method and device of selective recovery test execution |
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510131327.7A CN104750607B (en) | 2011-06-17 | 2011-06-17 | A kind of method and device of selective recovery test execution |
| CN201110163953.6A CN102831053B (en) | 2011-06-17 | 2011-06-17 | Scheduling method and device for test execution |
Related Parent Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201110163953.6A Division CN102831053B (en) | 2011-06-17 | 2011-06-17 | Scheduling method and device for test execution |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN104750607A true CN104750607A (en) | 2015-07-01 |
| CN104750607B CN104750607B (en) | 2018-07-06 |
Family
ID=47334202
Family Applications (3)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201510131327.7A Active CN104750607B (en) | 2011-06-17 | 2011-06-17 | A kind of method and device of selective recovery test execution |
| CN201110163953.6A Expired - Fee Related CN102831053B (en) | 2011-06-17 | 2011-06-17 | Scheduling method and device for test execution |
| CN201510130667.8A Active CN104809058B (en) | 2011-06-17 | 2011-06-17 | A kind of method and device of the concurrent quantity of the dynamic dispatching in test execution |
Family Applications After (2)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201110163953.6A Expired - Fee Related CN102831053B (en) | 2011-06-17 | 2011-06-17 | Scheduling method and device for test execution |
| CN201510130667.8A Active CN104809058B (en) | 2011-06-17 | 2011-06-17 | A kind of method and device of the concurrent quantity of the dynamic dispatching in test execution |
Country Status (2)
| Country | Link |
|---|---|
| CN (3) | CN104750607B (en) |
| HK (3) | HK1174108A1 (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109471794A (en) * | 2018-10-08 | 2019-03-15 | 深圳市广和通无线股份有限公司 | Method for testing software, device, computer equipment and readable storage medium storing program for executing |
| CN110347606A (en) * | 2019-07-15 | 2019-10-18 | 百度(中国)有限公司 | A kind of automated testing method, device, equipment and storage medium |
Families Citing this family (16)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103544103A (en) * | 2013-09-02 | 2014-01-29 | 烟台中科网络技术研究所 | Method and system for test, simulation and concurrence of software performance |
| CN103544102B (en) * | 2013-09-02 | 2016-01-06 | 烟台中科网络技术研究所 | A kind of software performance test analogy method and device |
| CN104834586B (en) * | 2014-02-10 | 2018-11-20 | 腾讯科技（深圳）有限公司 | Android interface automation test method, apparatus and system |
| CN105426231A (en) * | 2014-09-04 | 2016-03-23 | 腾讯科技（深圳）有限公司 | Multi-processing apparatus and multi-processing method |
| CN105607991A (en) * | 2014-11-20 | 2016-05-25 | 阿里巴巴集团控股有限公司 | Test method and device based on asynchronous threads |
| CN105740120B (en) * | 2014-12-11 | 2018-08-17 | 中国科学院软件研究所 | The monitoring in real time of software running process based on shared drive and control method and system |
| CN105915587B (en) * | 2016-04-05 | 2019-03-26 | 网宿科技股份有限公司 | Content delivery method, system and cache server |
| CN108632645A (en) * | 2017-03-17 | 2018-10-09 | 北京京东尚科信息技术有限公司 | Information demonstrating method and device |
| CN109508239A (en) * | 2017-09-15 | 2019-03-22 | 北京国双科技有限公司 | The control method and device of process |
| CN108255622A (en) * | 2018-01-17 | 2018-07-06 | 郑州云海信息技术有限公司 | The method and system that a kind of SMASH CLP functions are realized |
| CN110581787B (en) * | 2019-09-11 | 2020-12-22 | 成都安恒信息技术有限公司 | Application layer data quantity multiplication method applied to performance test |
| CN113535346B (en) * | 2020-04-21 | 2024-03-19 | 中移动信息技术有限公司 | Method, device, equipment and computer storage medium for adjusting thread number |
| CN112765019B (en) * | 2021-01-13 | 2024-01-19 | 北京鼎事兴教育咨询有限公司 | Pressure measurement method and device, storage medium and electronic equipment |
| CN113656175B (en) * | 2021-08-18 | 2022-07-08 | 北京百度网讯科技有限公司 | Method and equipment for training model based on distributed system |
| CN117240958A (en) * | 2022-06-06 | 2023-12-15 | 中兴通讯股份有限公司 | Audio and video processing performance test method and device |
| CN116089049B (en) * | 2023-04-07 | 2023-09-12 | 北京卡普拉科技有限公司 | Asynchronous parallel I/O request-based process synchronous scheduling method, device and equipment |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1477509A (en) * | 2002-08-19 | 2004-02-25 | 万达信息股份有限公司 | Process automatic restoring method |
| CN1842770A (en) * | 2003-08-28 | 2006-10-04 | 美普思科技有限公司 | Integrated mechanism for suspension and deallocation of computational threads of execution in a processor |
| US7725697B2 (en) * | 2003-08-28 | 2010-05-25 | Mips Technologies, Inc. | Symmetric multiprocessor operating system for execution on non-independent lightweight thread contexts |
| CN102063366A (en) * | 2009-11-18 | 2011-05-18 | 中兴通讯股份有限公司 | Method and system for debugging process |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1222882C (en) * | 2002-12-05 | 2005-10-12 | 华为技术有限公司 | Realization method for communication between tasks |
| WO2005022381A2 (en) * | 2003-08-28 | 2005-03-10 | Mips Technologies, Inc. | Integrated mechanism for suspension and deallocation of computational threads of execution in a processor |
| CN101167052B (en) * | 2005-04-29 | 2012-05-16 | 微软公司 | Application framework phasing model |
-
2011
- 2011-06-17 CN CN201510131327.7A patent/CN104750607B/en active Active
- 2011-06-17 CN CN201110163953.6A patent/CN102831053B/en not_active Expired - Fee Related
- 2011-06-17 CN CN201510130667.8A patent/CN104809058B/en active Active
-
2013
- 2013-01-24 HK HK13101051.9A patent/HK1174108A1/en not_active IP Right Cessation
-
2015
- 2015-08-31 HK HK15108419.9A patent/HK1207723A1/en unknown
- 2015-10-12 HK HK15109918.3A patent/HK1209216A1/en unknown
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1477509A (en) * | 2002-08-19 | 2004-02-25 | 万达信息股份有限公司 | Process automatic restoring method |
| CN1842770A (en) * | 2003-08-28 | 2006-10-04 | 美普思科技有限公司 | Integrated mechanism for suspension and deallocation of computational threads of execution in a processor |
| US7725697B2 (en) * | 2003-08-28 | 2010-05-25 | Mips Technologies, Inc. | Symmetric multiprocessor operating system for execution on non-independent lightweight thread contexts |
| CN102063366A (en) * | 2009-11-18 | 2011-05-18 | 中兴通讯股份有限公司 | Method and system for debugging process |
Non-Patent Citations (1)
| Title |
|---|
| 庞津津等: "分布式系统仿真技术研究及其实现", 《火力与指挥控制》 * |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109471794A (en) * | 2018-10-08 | 2019-03-15 | 深圳市广和通无线股份有限公司 | Method for testing software, device, computer equipment and readable storage medium storing program for executing |
| CN110347606A (en) * | 2019-07-15 | 2019-10-18 | 百度(中国)有限公司 | A kind of automated testing method, device, equipment and storage medium |
| CN110347606B (en) * | 2019-07-15 | 2022-11-08 | 百度(中国)有限公司 | Automatic testing method, device, equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN104750607B (en) | 2018-07-06 |
| CN102831053A (en) | 2012-12-19 |
| CN104809058A (en) | 2015-07-29 |
| HK1207723A1 (en) | 2016-02-05 |
| HK1209216A1 (en) | 2016-03-24 |
| CN102831053B (en) | 2015-05-13 |
| CN104809058B (en) | 2018-05-18 |
| HK1174108A1 (en) | 2013-05-31 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN104750607B (en) | A kind of method and device of selective recovery test execution | |
| CN110750458A (en) | Big data platform testing method and device, readable storage medium and electronic equipment | |
| CA3235906A1 (en) | Microservice full-link monitoring system and method | |
| JP2013521552A (en) | Method, system, and computer program for dispatching requests | |
| CN107038120B (en) | Software testing method and device | |
| KR20190081306A (en) | Method for allocating resource for bigdata analyzing software and apparatus for allocating virtual resource using the method | |
| CN117032903B (en) | Simulation debugging method and device, storage medium and electronic equipment | |
| CN112650676A (en) | Software testing method, device, equipment and storage medium | |
| CN113010392B (en) | Big data platform testing method, device, equipment, storage medium and system | |
| CN107179982B (en) | Cross-process debugging method and device | |
| CN109710474B (en) | Hard disk fault detection method and device, terminal and readable storage medium | |
| CN110781576A (en) | Simulation node scheduling method, device and equipment | |
| CN109117253A (en) | A kind of method and apparatus of micro-kernel scheduling | |
| US9612935B2 (en) | Enhanced resiliency testing by enabling state level control for request | |
| Ali et al. | Automated parallel GUI testing as a service for mobile applications | |
| Robert et al. | Software frameworks for SDR | |
| EP2713277B1 (en) | Latent defect identification | |
| CN101706752B (en) | Method and device for in-situ software error positioning | |
| CN111475394A (en) | Application testing method and device | |
| CN110750453A (en) | HTML 5-based intelligent mobile terminal testing method, system, server and storage medium | |
| TWI301938B (en) | Profiling systems and methods | |
| Liu et al. | Automatic cloud service testing and bottleneck detection system with scaling recommendation | |
| CN117252559A (en) | Business process processing method, device, computer equipment and storage medium | |
| CN112860502A (en) | Fault simulation method, equipment, server and storage medium | |
| CN116055349A (en) | Method, device and equipment for detecting stream data |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| REG | Reference to a national code |
Ref country code: HK Ref legal event code: DE Ref document number: 1207723 Country of ref document: HK |
|
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20230524 Address after: Room 1-2-A06, Yungu Park, No. 1008 Dengcai Street, Sandun Town, Xihu District, Hangzhou City, Zhejiang Province Patentee after: Aliyun Computing Co.,Ltd. Address before: Box 847, four, Grand Cayman capital, Cayman Islands, UK Patentee before: ALIBABA GROUP HOLDING Ltd. |
|
| TR01 | Transfer of patent right |