Test example・Aging test under high load

16/09/2021Test qualityy

High load aging is important to check stability under high load

In order to confirm the stable operation of the embedded software, it is necessary to confirm the operation of the embedded software in various states . In another article, I introduced a startup test that focuses on the processing at startup , but even in normal mode, a test that focuses on a slightly special situation is required. One of the slightly special situations is high load . When a high load has occurred, is in the embedded software in the state of the normal load is executed frequently process that does not so much run Runode, there bugs have potentially problem and will occur. The high load aging test is a test to identify such potential bugs. In this article the internal operation of the built-in software when a high load is applied on the basis of, the notes of when you think the high-load aging test will continue to introduce about.

Under high load conditions, embedded software stores processes waiting to be executed internally.

Any software receives a processing request via communication from an external device or input from an operator , executes the processing, and returns the result repeatedly. Requests for the same process may come from multiple external devices or may be entered by multiple operators at the same time . Such a state happened punished when designing policy for the management of the method is until the end of ①1 one of the processing is not accepted following the processing of error in the return or ② a plurality of processing the request of processing that arrive later because It either accepts the request , stores it internally, processes it in order, and returns the result.

In the case of embedded software, real-time performance and multitasking performance are often required, so we often adopt a design policy of accumulating processing requests inside (2 ). In order to store processing requests inside this, a relatively complicated mechanism is required inside, so there is a possibility that potential bugs are lurking there . Therefore, high-load aging is required to identify the potential bugs.

High load aging test back and forth between high load and overload

If the embedded software has a function to store processing requests internally , the processing load can be roughly divided into the following four categories.

  1. Low load　: No internal processing-waiting requests are stored (processing requests are immediately responded to)
  2. Normal load : Internal processing wait requests are accumulated, but 70% or less (processing requests are answered after a short wait)
  3. High load　: 90% or more of the requests waiting for internal processing are accumulated, but they have not overflowed yet (waiting time becomes long)
  4. Overload　: The state of waiting for processing is full inside and no more can be stored (processing is not possible and an error response is returned).

If there is a function to store processing requests internally, even if a processing request that exceeds the processing performance per unit time occurs temporarily, the processing requests are stored internally and then processed in order. Will be done. This is the state of normal load, but when the load becomes higher from such a state and the demand for processing that accumulates inside increases and exceeds 90% of the maximum number of processing requests that can be stored, it is finally stored. The limit is approaching and it becomes dangerous. This is a high load condition . If more processing requests are accumulated from the high load state and it is finally impossible to store them inside, the processing requests arriving after that will be considered unprocessable and an error response will be returned , resulting in an overloaded state . ..

Various latent bugs can be found in a high load state where the load sometimes becomes overloaded and then returns to the high load in this high load state . Therefore, in the high load aging test, aging is performed by applying a load aiming at the load at the boundary between the high load and the overload.

What is happening in embedded software under high load or overload?

A state of high load , even if the request was crowded accumulated inside does not exceed the limit does not have a separate problem . The normal processing is performed only by repeating the registration and execution of the normal processing, and the response is slow even from the side requesting the processing. If you compare it to a dam built upstream of the river, it is approaching the full water level, but it is not yet full and it is in a state of enduring .

However, when the load further increases from here and the state becomes overloaded, the limit of accumulating the demand inside is finally exceeded. If the limit is exceeded, no more processing will be stored internally, so requests for processing that come after that will not be accepted and an error response will be returned as unprocessable. At this time, the embedded software is running full processing of the data that stores the processing requests that have been prepared .

If it is a queue structure, a response with no remaining queue is returned when trying to retrieve a free queue, or if it is a table structure, an error with no free entry is returned. The processing when the last one of the prepared data is used up and there is no more left is a special processing that requires a different movement from the normal processing in the software . Since it is a special process, there are many things to be careful about, and bugs are easy to hide . In the case of a dam, it is a scene where the water is finally full and the dam overflows, so it is released in an emergency . Since the emergency discharge is a special processing that is usually not carried out, in the lower reaches of the river broadcasting of alarm -related or the contacted to public office retriever, very similar to that of increases to various and attention.

Bugs hidden between high load and overload switching

When the load changes from high load to overload , the software internally executes the process of using up the last one of the data that stores the process request , and after that, an error response is returned to the process request . In response to the error response, the processing corresponding to the error also works on the side that requested the processing. On the other hand, when the overload is resolved and the load returns to high , the first one of the free frames of the data structure that stores the processing requests is created inside the software, and it is registered in the management data for managing the free frames. .. This first one is also a special process that usually doesn’t work, so bugs are likely to lie here as well.

Switching between high load and overload means that switching between high load and overload occurs frequently . Such a movement situation of switching from one state to another is also a place where software bugs are likely to be hidden, and further, the last one of the free space of data is used up internally or the first one is managed. Boundary data processing , such as putting it in, is also a place where bugs are likely to lie.

Therefore, in the high load aging test, in order to identify the potential bugs hidden in these parts, it is better to perform aging that operates for a long time under a load that goes back and forth between high load and overload.

High load aging requires design of what load and how much

In this way, in high-load aging, applying a load that goes back and forth between high load and overload is effective in identifying potential bugs in the software. Therefore, what is important is what kind of load is applied . Applying a load means, in other words, pushing a large amount of input in a short time . Therefore, the target to which a high load is applied is all the inputs of the device .

If the receiving function of the communication load of receiving the high-load aging for, function that accepts the processing of something there is the load of the request of the processing to the high-load aging have attached to, that if there is a screen input for the input high Various high load aging such as load aging can be considered. Their high load aging, it may be performed solely as CPU and memory device applying a high load to the hardware resources from the viewpoint, to implement the high-load aging for all input at the same time as There is also a way of thinking.

In any case, how much high load or overload is applied to what kind of load and how long it is aged depends on the device to be tested, so it should be carefully considered at the test design stage. Let’s do an efficient high load aging test.

In high load aging, don’t forget to check the recovery after removing the load.

Last but not least, after performing a high load aging test , check that the equipment is operating normally with all high loads removed and returned to normal load, recovery from high load. Don’t forget to check the above as a test item.

There are rare potential bugs, such as moving between high and overloaded conditions, but then malfunctioning after the normal load returns . The cause is that some kind of dynamic resource leak occurred during the process of switching between high load and overload , or the internal state transition was abnormal . It is also important to confirm the recovery from the high load in order to confirm whether such a thing has happened.

Next to high load aging is aging on poor quality channels.

The high load aging test is a test that can be performed on any device that has an input. Next, only devices with communication functions are targeted, but aging tests on poor quality communication paths are also important for confirming the stability of devices, so let’s introduce them in the next article.

Next :  Test example・Aging test on poor quality channels
Back :  Test example・ Deterioration test of secondary storage devices such as flash memory and HDD
Return to :  Testing is the only way to guarantee software quality

Test qualityy

Posted by グータラ親父