CN116401150A - Method and device for testing real-time operating system, computer equipment and storage medium - Google Patents
Method and device for testing real-time operating system, computer equipment and storage medium Download PDFInfo
- Publication number
- CN116401150A CN116401150A CN202310210695.5A CN202310210695A CN116401150A CN 116401150 A CN116401150 A CN 116401150A CN 202310210695 A CN202310210695 A CN 202310210695A CN 116401150 A CN116401150 A CN 116401150A
- Authority
- CN
- China
- Prior art keywords
- test
- partition
- user
- memory
- user partition
- 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.)
- Pending
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 514
- 238000000034 method Methods 0.000 title claims abstract description 58
- 238000005192 partition Methods 0.000 claims abstract description 543
- 238000004590 computer program Methods 0.000 claims abstract description 45
- 238000012163 sequencing technique Methods 0.000 claims description 27
- 238000013507 mapping Methods 0.000 claims description 22
- 230000002093 peripheral effect Effects 0.000 claims description 19
- 230000008569 process Effects 0.000 claims description 15
- 238000012545 processing Methods 0.000 claims description 9
- 238000007726 management method Methods 0.000 description 26
- 238000010586 diagram Methods 0.000 description 9
- 238000004891 communication Methods 0.000 description 6
- 238000012544 monitoring process Methods 0.000 description 6
- 230000000903 blocking effect Effects 0.000 description 5
- 238000002955 isolation Methods 0.000 description 5
- 238000013100 final test Methods 0.000 description 4
- 230000006870 function Effects 0.000 description 4
- 230000008859 change Effects 0.000 description 3
- 230000004044 response Effects 0.000 description 3
- 238000010998 test method Methods 0.000 description 3
- 238000013500 data storage Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000011056 performance test Methods 0.000 description 2
- 238000000638 solvent extraction Methods 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- OKTJSMMVPCPJKN-UHFFFAOYSA-N Carbon Chemical compound [C] OKTJSMMVPCPJKN-UHFFFAOYSA-N 0.000 description 1
- 230000002159 abnormal effect Effects 0.000 description 1
- 238000004458 analytical method Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 229910021389 graphene Inorganic materials 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000011076 safety test Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
- G06F9/5038—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering the execution order of a plurality of tasks, e.g. taking priority or time dependency constraints into consideration
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Debugging And Monitoring (AREA)
Abstract
The present application relates to a method, apparatus, computer device, storage medium and computer program product for testing a real-time operating system. The method comprises the following steps: the method comprises the steps of obtaining test tasks of a real-time operating system, distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition according to the distributed test tasks to test, obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different, merging the kernel resource scheduling logs of each user partition to obtain a kernel resource testing result of the real-time operating system.
Description
Technical Field
The present invention relates to the field of computer technology, and in particular, to a method, an apparatus, a computer device, a storage medium, and a computer program product for testing a real-time operating system.
Background
With the development of information technology, in some critical fields with higher security requirements, conventional operating systems, such as a window operating system, cannot meet the task requirements of production monitoring. Thus, a high-security real-time operating system is presented, which can accept and respond at a high speed in the face of external events or data. Performance testing of the system is often required before the real-time operating system is used.
The existing real-time operating system performance test method is often that a single test user tests the system, and the test result is not accurate enough due to the influence of test user experience and the contingency of test tasks.
Disclosure of Invention
In view of the foregoing, it is desirable to provide a method, apparatus, computer device, computer readable storage medium, and computer program product for testing a real-time operating system that can improve the testing effect.
In a first aspect, the present application provides a method for testing a real-time operating system, where the method includes:
Acquiring a test task of the real-time operating system;
distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different;
and merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In one embodiment, the step of controlling each user partition to call a memory partition corresponding to each user partition to perform a test according to the allocated test task, and obtaining a kernel resource scheduling log of each user partition includes:
acquiring the priority of each user partition;
sequencing according to the priority of each user partition to obtain a sequencing result;
and sequentially controlling each user partition according to the sequencing result, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
In one embodiment, the step of sequentially controlling each user partition according to the sorting result to call the memory partition corresponding to each user partition according to the allocated test task to perform a test, and obtaining the kernel resource scheduling log of each user partition includes:
And according to the sequencing result, sequentially controlling all the user partitions from the highest priority level, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
In one embodiment, before the step of assigning the test task to the first preset number of user partitions, the method includes:
after the test task is obtained, creating a first number of user partitions for a real-time kernel of the real-time operating system; creating a second number of memory partitions for the real-time operating system memory, wherein the second number is greater than or equal to the first number;
at least one memory partition is assigned to a user partition.
In one embodiment, the step of distributing the test task to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition to test according to the distributed test task, and obtaining a kernel resource scheduling log of each user partition includes:
distributing the test tasks to a first preset number of user partitions, and determining the corresponding relation between each user partition and the test subtasks, wherein the test tasks comprise a plurality of test subtasks;
Determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition;
and controlling each user partition to call the corresponding memory partition to test according to the allocated test task according to the mapping table.
In one embodiment, the method further comprises:
in the process of controlling each user partition to call a memory partition corresponding to each user partition for testing according to the allocated testing task, acquiring a memory partition, storage resources and a resource using result of a CPU in the real-time operating system through peripheral equipment;
and obtaining the test result of the real-time operating system according to the kernel resource test result and the resource use result.
In a second aspect, the present application provides a test apparatus for a real-time operating system, the apparatus comprising:
the acquisition module is used for acquiring the test task of the real-time operating system;
the test module is used for distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different;
And the processing module is used for merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In a third aspect, the present application provides a computer device comprising a memory storing a computer program and a processor implementing the following methods and steps when executing the computer program:
acquiring a test task of the real-time operating system;
distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different;
and merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In a fourth aspect, the present application provides a computer readable storage medium having stored thereon a computer program which when executed by a processor performs the following methods and steps:
acquiring a test task of the real-time operating system;
Distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different;
and merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In a fifth aspect, the present application provides a computer program product comprising a computer program which, when executed by a processor, performs the following methods and steps:
acquiring a test task of the real-time operating system;
distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different;
and merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
According to the testing method, the testing device, the computer equipment, the storage medium and the computer program product of the real-time operating system, the testing tasks are distributed to the first preset number of user partitions, the user partitions are controlled to call the memory partitions corresponding to the user partitions according to the distributed testing tasks to test, kernel resource scheduling logs of the user partitions are obtained, the memory partitions called by each user partition are different, the kernel resource scheduling logs of the user partitions are combined to obtain kernel resource testing results of the real-time operating system, and the method comprises the user partitions and the memory partitions, wherein the partitions called by each user partition are different, so that the testing data isolation effect is improved, and the safety of data is ensured; on the other hand, the users are partitioned, the test data of the users are different from each other, the influence of individual experience of the test users is avoided, if the test data of the users are the same, the accidental of the test task is avoided, the kernel resource scheduling logs corresponding to the multiple user partitions and the multiple user partitions are synthesized, a final kernel resource test report is obtained, and the accuracy of the test report is further improved.
Drawings
FIG. 1 is an application environment diagram of a method of testing a real-time operating system in one embodiment;
FIG. 2 is a flow chart of a method for testing a real-time operating system in one embodiment;
FIG. 3 is a flow diagram of a kernel resource scheduling log for a user partition in one embodiment;
FIG. 4 is a diagram illustrating a call relationship between a user partition and a memory partition in one embodiment;
FIG. 5 is a flow diagram of a method for creating memory partitions in one embodiment;
FIG. 6 is a flow diagram of a method of testing partition isolation for a real-time operating system in one embodiment;
FIG. 7 is a schematic diagram of a real-time operating system in one embodiment;
FIG. 8 is a block diagram of a test device of a real-time operating system in one embodiment;
fig. 9 is an internal structural diagram of a computer device in one embodiment.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the present application will be further described in detail with reference to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the present application.
The method for testing the real-time operating system, which is provided by the embodiment of the application, can be applied to an application environment shown in fig. 1. Wherein the test terminal 102 communicates with the test monitor 104 through a network. The data storage system may store the monitoring data recorded by the test monitor 104. The data storage system may be integrated on the test monitor 104 or may be located on a cloud or other network server.
The test terminal 102 acquires a test task of a real-time operating system; the test terminal 102 distributes test tasks to a first preset number of user partitions, and controls each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks to obtain a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different; the test terminal 102 merges the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
The test terminal 102 may be, but not limited to, various personal computers, notebook computers, smart phones, tablet computers, internet of things devices, and portable wearable devices, where the internet of things devices may be smart speakers, smart televisions, smart air conditioners, smart vehicle devices, and the like. The portable wearable device may be a smart watch, smart bracelet, headset, or the like. The test monitor 104 may be implemented as a stand-alone server or as a server cluster of multiple servers.
In one embodiment, as shown in fig. 2, a method for testing a real-time operating system is provided, and the method is applied to the test terminal in fig. 1 for illustration, and includes the following steps:
S202, acquiring a test task of the real-time operating system.
The operating system is first layer software based on computing hardware, and is a bridge for communication between the hardware and other software. The operating system can control other programs to run, manage system resources, provide most basic computing functions, such as managing and configuring memory, determining the priority of supply and demand of system resources, and the like, and also provide basic service programs, such as a file system unit, a memory management unit, a master control interface and a time slice scheduling unit. Because of the special functions of the operating system, the performance of the operating system needs to be tested before the operating system is formally used.
The operating system can comprise a real-time operating system and a time-sharing operating system, wherein the real-time operating system can finish data processing in a short time when external events or data are generated, and returns data response to a user, and the time-sharing operating system can finish a plurality of submitted tasks in turn by fixed time slices or different time slices for a computer according to a certain time interval.
The test task may be performance test content of the real-time operating system, and specifically may include: the kernel resource of the operating system manages response speed, accuracy of time slice scheduling, integrity of a file system and the like.
Specifically, the manner of acquiring the test task of the real-time operating system may be to pre-configure the test task in the test terminal by reading the user.
The test tasks can be preset by at least two users, and the test tasks configured by the users can be the same or different. When the testing tasks configured by the user are the same, testing the operating system according to the same testing tasks to obtain a plurality of testing results, analyzing the testing results, and eliminating accidental factors to obtain a final testing result. When the testing tasks configured by the users are different, testing the operating system according to a plurality of different testing tasks to obtain a plurality of testing results, summarizing different testing contents in the testing results, and analyzing the same testing contents in the testing results to obtain a final testing result.
S204, distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different.
The user partitions may be in one-to-one correspondence with the test users, and the first preset number is at least one.
Specifically, the test task is divided into a plurality of test subtasks, and then the plurality of test subtasks are allocated to a first preset number of user partitions. It should be noted that, when the test subtasks are the same, the test results of the real-time operating system are analyzed according to the same test subtasks to obtain a final test result, and when the test subtasks are different, the test results of the real-time operating system are summarized according to the test tasks, including: and adding the parts of the test contents, which are not intersected, analyzing the parts of the test contents, and summarizing the test results of the parts and the parts to obtain a final test result.
The test tasks may be stored in a user partition, and the plurality of test subtasks are stored in each user partition.
The memory partition may partition a memory in the computer, where the memory may be volatile storage. The partitioning of the memory of the computer is performed at a time, which may be one time before the real-time operating system of the computer is tested, and the result of the memory partitioning does not change until all the tests are completed, or one time before the real-time operating system of the computer is tested each time.
Specifically, the call relationship between the user partition and the memory partition may be a one-to-one and one-to-many relationship, that is, the test task of one user partition may be performed in at least one memory partition.
The kernel resource scheduling log may include a memory management test result, a time slice scheduling test result, and a file system test result. The memory management test result may be the memory size, the number of memory partitions, etc., the time slice scheduling test result may be the priority of the execution sequence of the test tasks among the user partitions, the execution time of the test tasks, etc., and the file system test result may be the size of the storage space occupied by the test tasks, etc.
S206, combining the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
The method comprises the steps of analyzing different test contents in the kernel resource scheduling logs of each user partition, summarizing the same test contents in the kernel resource scheduling logs of each user partition, and combining the two to obtain a kernel resource test result of the real-time operating system.
Specifically, taking an example that the user partition includes three user partitions, explanation is made: the kernel resource scheduling logs corresponding to the user partition 1 comprise a memory management test result 1, a time slice scheduling test result 1 and a file system test result 1, the kernel resource scheduling logs corresponding to the user partition 2 comprise a memory management test result 2 and a time slice scheduling test result 2, the kernel resource scheduling logs corresponding to the user partition 3 are memory management test results 3, at the moment, the memory management test result 1, the memory management test result 2 and the memory management test result 3 are analyzed to obtain an analyzed memory management test result, the time slice scheduling test result 1 and the time slice scheduling test result 2 are analyzed to obtain an analyzed time slice scheduling test result, and the analyzed time slice scheduling test result is summarized with the file system test result 1 to obtain a kernel resource test result of the real-time operating system.
In the method for testing the real-time operating system, the testing tasks are distributed to the first preset number of user partitions by acquiring the testing tasks of the real-time operating system, and each user partition is controlled to call a memory partition corresponding to each user partition for testing according to the distributed testing tasks, so that the kernel resource scheduling logs of each user partition are obtained, wherein the memory partition called by each user partition is different, and the kernel resource scheduling logs of each user partition are combined to obtain the kernel resource testing result of the real-time operating system. On the other hand, the users are partitioned, the test data of the users are different from each other, the influence of individual experience of the test users is avoided, the multiple user partitions and the kernel resource scheduling logs corresponding to the multiple user partitions are synthesized, a final kernel resource test report is obtained, and the accuracy of the test report is further improved.
In one embodiment, as shown in the flow chart of the kernel resource scheduling log of the user partition in fig. 3, the step of obtaining the kernel resource scheduling log of each user partition by each control partition to call the memory partition corresponding to each user partition according to the allocated test task for testing includes:
S302, acquiring the priority of each user partition.
The priority of the user partition may be an operation order of the test tasks corresponding to the user partition, and the higher the level of the priority of the user partition is, the higher the operation order of the test tasks corresponding to the user partition is.
Specifically, the priorities of the user partitions may include: and when the priority of the user partition is the first priority, the test task corresponding to the user partition is in a ready state, and when the priority of the user partition is the third priority, the test task corresponding to the user partition is in a blocking state.
When the test task corresponding to the user partition is in the running state, the representative processor is processing the task, and only one task is in the running state at any time for the single-core processor.
When the test task corresponding to the user partition is in a ready state, the test task is ready, i.e. the test task is not blocked or suspended, and can be run at any time. Specifically, when the test task corresponding to the user partition is in a ready state, the corresponding test task corresponding to at least one user partition is in an operation state. In other words, when all the first-priority test tasks of the user partition are executed, the second-priority test tasks of the user start to be executed.
When the test task corresponding to the user partition is in a blocking state, the test task is waiting for the execution of a specific task, and the specific task can be the test task or other tasks including calling functions.
Specifically, when the specific task is executed, the blocked test task is converted into a ready test task. It should be noted that, the blocking state task may set a timeout period, and if the timeout period exceeds the preset period, the specific task is still not executed or is not executed, the blocking state test task forcedly exits the blocking state and enters the ready state.
S304, sorting is carried out according to the priority of each user partition, and sorting results are obtained.
The priorities of the user partitions may be ranked according to the priority from high to low, a first ranking result is obtained, and the execution sequence of the user partitions may be defined according to the first ranking result.
The method can also sequence the test sub-tasks in the test tasks in the user partition to obtain a sequencing result of the test sub-tasks, wherein each test sub-task can be different test contents in one test task, such as response speed of kernel resource management of an operating system, accuracy of time slice scheduling and integrity of a file system. Specifically, the tasks of each test may be sequenced in priority, so as to obtain a second sequencing result, and the execution sequence in each task of each test may be defined according to the second sequencing result.
And S306, sequentially controlling each user partition according to the sequencing result, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
The memory partition of the user partition may be called according to the priority of each user partition in the first sorting result to perform testing, for example, if the priority of the user partition 1 is greater than the priority of the user partition 2, testing is performed according to the memory partition corresponding to the user partition 1, and then testing is performed according to the memory partition corresponding to the user partition 2.
The testing sub-task in the user partition 1 may be tested according to the second sorting result, specifically, if the priority of the testing sub-task 1 is greater than the priority of the testing sub-task 2, the memory partition corresponding to the user partition 1 is called according to the testing sub-task 1 to perform testing, and then the memory partition corresponding to the user partition 1 is called according to the testing sub-task 2 to perform testing.
In this embodiment, the priority of each user partition is used to determine the sequence of calling the memory partition by the user partition, so that the important user partition, that is, the user partition with the front priority ordering result, is tested first, and then, the test of each user partition is completed, and the completeness of the test is ensured.
In one embodiment, according to the sorting result, sequentially controlling each user partition to call a memory partition corresponding to each user partition according to the allocated test task to perform a test, and obtaining a kernel resource scheduling log of each user partition, including: and according to the sequencing result, sequentially controlling all the user partitions from the highest priority level, calling the memory partition corresponding to each user partition according to the allocated testing task to test, and obtaining the kernel resource scheduling log of each user partition.
Specifically, as shown in a schematic diagram of a call relationship between a user partition and a memory partition shown in fig. 4, if the priority of the user partition 1 is greater than that of the user partition 2, the corresponding memory 1 is called according to the user partition 1 according to the test task 1 to perform the test, and then the corresponding memory 2 is called according to the user partition 2 according to the test task 2 to perform the test.
The sequence of the test sub-tasks can be determined according to the priority sequence among the test sub-tasks in the test tasks. Specifically, as shown in fig. 4, if the priority level of the test subtask 1 is greater than the priority level of the test subtask 2 and greater than the priority level of the test subtask 3, the test subtask 1 allocated by the user partition 1 and the user partition 2 is executed to call the memory partition 1 and the memory partition 2 for testing, then the test subtask 2 allocated by the user partition 1 is executed to call the memory partition 1 for testing, and finally the test subtask 3 allocated by the user partition 2 is executed to call the memory partition 2 for testing.
The priority of the user partition can be obtained in real time, if the priority of the user partition is greater than the priority of the current user partition, the process of calling the memory partition by the assigned test task of the current user partition is stopped, and the process of the user partition with higher priority is executed. And a priority preemption mode is adopted, and the memory partition corresponding to each user partition is called to test, so that the real-time performance of the test process is ensured.
In this embodiment, the priority of each user partition is determined to determine the sequence of calling the memory partition by the user partition, so that the important user partition, that is, the user partition with the front priority ordering result, is tested first, and then, the test of each user partition is completed, if a process with higher priority appears, the process with higher priority is executed first, and the real-time performance of the test process can be ensured.
In one embodiment, before the step of assigning the test tasks to the first predetermined number of user partitions, the method comprises: after obtaining the test task, creating a first number of user partitions for a real-time kernel of the real-time operating system; creating a second number of memory partitions for the memory of the real-time operating system, wherein the second number is greater than or equal to the first number; at least one memory partition is assigned to a user partition.
The real-time operating system generally comprises a real-time kernel, a network component and the like. The real-time kernel is generally multi-tasked, and functions such as task management, timer management, memory management, communication and synchronization among tasks, interrupt management and the like are realized. The network component is connected with the peripheral equipment and the monitoring test end PC through interfaces to realize the communication protocol of the link layer.
Wherein the number of times the user partition is created and the memory is created is at least once. When the number of times of creating the user partition and the memory partition is one time, the user partition and the memory partition can be created once after the test task is obtained, when the number of times of creating the user partition and the memory partition is multiple times, the user partition and the memory partition can be created once after the test task is obtained each time, and/or when the current test task is tested, the test task is temporarily obtained, and at this time, the user partition and the memory partition can be created again.
It should be noted that, there may be an association between each test task, for example, a plurality of test users test a real-time operating system in a period of time, and there may be an association between test tasks corresponding to each test user, where a user partition and a memory partition may not be repeatedly created, i.e. an original user partition and a memory partition may be used. There may be no association between each test task, for example, before the real-time operating system fails, there may be no association between the test tasks corresponding to the two test users after the real-time operating system is overhauled, and at this time, the user partition and the memory partition need to be re-created.
And allocating at least one memory partition to a user partition, wherein the relationship between the user partition and the memory partition is one-to-one or one-to-many, so that the exclusivity of the user partition on the processor resource is ensured.
In this embodiment, by allocating at least one memory partition to a user partition, the exclusivity of the user partition to the processor resource is ensured, and the security of the real-time operating system during testing is improved.
In one embodiment, as shown in a flow chart of a method for creating memory partitions in fig. 5, the steps of allocating test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the allocated test tasks, and obtaining a kernel resource scheduling log of each user partition include:
s502, distributing test tasks to a first preset number of user partitions, and determining the corresponding relation between each user partition and the test subtasks, wherein the test tasks comprise a plurality of test subtasks.
The test tasks comprise a plurality of test subtasks, and it can be understood that the test subtasks comprise different test contents. The number of the test subtasks is greater than or equal to the number of the user partitions, and the user partitions at least correspond to one test subtask, and the test subtask corresponding to the user partition is taken as an example for explanation.
Specifically, the user partition 1 and the user partition 2 correspond to a test subtask 1 and a test subtask 2 respectively, the test subtask 1 may be at least one of a kernel management test, a time slice scheduling test and a file system test, and the test subtask 2 may also be at least one of a kernel management test, a time slice scheduling test and a file system test.
S504, determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition.
The corresponding relationship between the type of the test subtask and the memory partition is determined according to the corresponding relationship between each user partition and the test subtask, specifically, the corresponding relationship between the type of the test subtask and the memory partition may correspond to the memory partition according to the type of the test subtask, for example, when the type of the test subtask is any one of kernel management test, time slice scheduling test and file system test, there is one memory partition corresponding to the test subtask.
Wherein, the mapping table of logical address-physical address needs to satisfy the exclusive constraint of the user partition.
Specifically, the test subtasks obtain physical addresses of the test subtasks in the memory partition according to the mapping table of the logical addresses and the physical addresses, and each test subtask has a mapping relation from the logical addresses to the physical addresses, so that the logical address spaces of the test subtasks can be overlapped, but the mapped physical spaces cannot be overlapped, and the partition is isolated in space.
S506, controlling each user partition to call the corresponding memory partition to test according to the allocated test task according to the mapping table.
And controlling each user partition to call the corresponding memory partition for testing according to the allocated test task according to the corresponding relation between the logical address of the test subtask of the mapping table and the physical address of the memory partition.
In this embodiment, by establishing a mapping table of logical addresses-physical addresses, the user partition, the test subtask and the memory partition are linked, so that it can be ensured that physical spaces after mapping the user partition and the test subtask do not overlap, and thus partition isolation in space is achieved.
In one embodiment, in the process of controlling each user partition to call a memory partition corresponding to each user partition for testing according to the allocated testing task, acquiring a memory partition, storage resources and a resource using result of a CPU in a real-time operating system through peripheral equipment; and obtaining a test result of the real-time operating system according to the kernel resource test result and the resource use result.
Wherein, peripheral device refers to devices in the computer system other than the host computer, including: input/output devices, external memory, peripheral processors, etc., the peripheral devices provide devices for the real-time kernel to communicate with the outside world, and specifically, the peripheral devices may be peripheral devices of a test terminal, where the peripheral devices of the test terminal are connected with the test terminal.
The peripheral equipment of the test terminal obtains the resource use results of the memory partition, the storage resource and the CPU from the test terminal, and combines the resource use results of the memory partition, the storage resource and the CPU to obtain the resource use results, wherein the resource use results also comprise the identification of abnormal resource use and the like.
Obtaining a test result of the real-time operating system according to the kernel resource test result and the resource use result
In the embodiment, in the process of controlling each user partition to call the memory partition corresponding to each user partition for testing according to the allocated testing task, the peripheral testing equipment obtains the resource using result, so that the integrity of the safety test of the real-time operating system can be improved.
In one embodiment, as shown in fig. 6, a method for testing partition isolation of a real-time operating system is provided, including:
S602, acquiring a test task of the real-time operating system.
The real-time operating system as shown in fig. 7 includes: a software part, a hardware part, a monitoring part and a peripheral testing part.
The software part comprises time-sharing isolation of users to obtain a user partition 1, a user partition 2 and a user partition 3. The software part also comprises a kernel resource management module, wherein the kernel resource management module comprises a main control interface, a memory management unit, a time slice scheduling unit and a file system unit.
The main control interface is connected with the monitoring end PC, and the kernel resource test result is sent to the monitoring end PC through the main control interface. The memory management unit, i.e. the MMU memory management unit (central memory management unit), partitions the memory in the hardware portion according to the memory management unit, and obtains each memory partition. And the time slice scheduling unit partitions each user to obtain each user partition. The file system unit records the use of storage space by each part in the kernel resource management module.
S604, after obtaining the test task, creating a first number of user partitions for a real-time kernel of the real-time operating system.
S606, creating a second number of memory partitions for the memory of the real-time operating system, wherein the second number is greater than or equal to the first number.
S608, at least one memory partition is allocated to a user partition.
S610, distributing the test tasks to a first preset number of user partitions, and acquiring the priorities of the user partitions.
And S612, sorting according to the priorities of the user partitions to obtain sorting results.
And S614, according to the sequencing result, sequentially controlling all the user partitions from the highest priority level, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
The memory partition called by each user partition is different.
S616, the kernel resource scheduling logs of each user partition are combined, and a kernel resource test result of the real-time operating system is obtained.
The step of distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining the kernel resource scheduling log of each user partition comprises the following steps: distributing a test task to a first preset number of user partitions, and determining the corresponding relation between each user partition and a test subtask, wherein the test task comprises a plurality of test subtasks; determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition; and controlling each user partition according to the mapping table, and calling the corresponding memory partition according to the allocated test task to test.
S618, in the process of controlling each user partition to call the memory partition corresponding to each user partition for testing according to the allocated testing task, the peripheral equipment is used for acquiring the memory partition, the storage resource and the resource using result of the CPU in the real-time operating system.
S620, according to the kernel resource testing result and the resource using result, a testing result of the real-time operating system is obtained.
In this embodiment, by acquiring a test task of a real-time operating system, allocating the test task to a first preset number of user partitions, and controlling each user partition to call a memory partition corresponding to each user partition according to the allocated test task to perform a test, so as to obtain a kernel resource scheduling log of each user partition, where the memory partition called by each user partition is different, and the kernel resource scheduling logs of each user partition are combined to obtain a kernel resource test result of the real-time operating system. On the other hand, the users are partitioned, the test data of the users are different from each other, the influence of individual experience of the test users is avoided, the multiple user partitions and the kernel resource scheduling logs corresponding to the multiple user partitions are synthesized, a final kernel resource test report is obtained, and the accuracy of the test report is further improved.
It should be understood that, although the steps in the flowcharts related to the embodiments described above are sequentially shown as indicated by arrows, these steps are not necessarily sequentially performed in the order indicated by the arrows. The steps are not strictly limited to the order of execution unless explicitly recited herein, and the steps may be executed in other orders. Moreover, at least some of the steps in the flowcharts described in the above embodiments may include a plurality of steps or a plurality of stages, which are not necessarily performed at the same time, but may be performed at different times, and the order of the steps or stages is not necessarily performed sequentially, but may be performed alternately or alternately with at least some of the other steps or stages.
Based on the same inventive concept, the embodiment of the application also provides a testing device of the real-time operating system for realizing the testing method of the real-time operating system. The implementation of the solution provided by the device is similar to the implementation described in the above method, so the specific limitation in the embodiments of the testing device for one or more real-time operating systems provided below may be referred to the limitation of the testing method for the real-time operating system hereinabove, and will not be repeated herein.
In one embodiment, as shown in fig. 8, there is provided a test apparatus for a real-time operating system, including: an acquisition module 802, a test module 804, and a processing module 806, wherein:
an acquiring module 802, configured to acquire a test task of a real-time operating system;
the test module 804 is configured to allocate a test task to a first preset number of user partitions, and control each user partition to call a memory partition corresponding to each user partition according to the allocated test task to perform a test, so as to obtain a kernel resource scheduling log of each user partition, where the memory partition called by each user partition is different;
and a processing module 806, configured to combine the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In one embodiment, the testing module 804 is further configured to obtain a priority of each user partition; sequencing according to the priority of each user partition to obtain a sequencing result; and sequentially controlling each user partition according to the sequencing result, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
In one embodiment, the test module 804 is further configured to sequentially control each user partition from the highest priority level according to the sequencing result, call the memory partition corresponding to each user partition according to the allocated test task, and perform a test, so as to obtain a kernel resource scheduling log of each user partition.
In one embodiment, the test device of the real-time operating system further comprises an allocation module, configured to create a first number of user partitions for a real-time kernel of the real-time operating system after obtaining the test task; creating a second number of memory partitions for the memory of the real-time operating system, wherein the second number is greater than or equal to the first number; at least one memory partition is assigned to a user partition.
In one embodiment, the test module 804 is further configured to assign a test task to a first preset number of user partitions, determine a correspondence between each user partition and a test subtask, where the test task includes a plurality of test subtasks; determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition; and controlling each user partition according to the mapping table, and calling the corresponding memory partition according to the allocated test task to test.
In one embodiment, the testing device of the real-time operating system further includes a peripheral testing module 804, configured to obtain, through a peripheral device, a result of using a memory partition, a storage resource, and a resource of the CPU in the real-time operating system in a process of controlling each user partition to call the memory partition corresponding to each user partition for testing according to the allocated testing task; and obtaining a test result of the real-time operating system according to the kernel resource test result and the resource use result.
The modules in the test device of the real-time operating system may be implemented in whole or in part by software, hardware, or a combination thereof. The above modules may be embedded in hardware or may be independent of a processor in the computer device, or may be stored in software in a memory in the computer device, so that the processor may call and execute operations corresponding to the above modules.
In one embodiment, a computer device is provided, which may be a server, and the internal structure of which may be as shown in fig. 9. The computer device includes a processor, a memory, an Input/Output interface (I/O) and a communication interface. The processor, the memory and the input/output interface are connected through a system bus, and the communication interface is connected to the system bus through the input/output interface. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The database of the computer device is used to store test task data. The input/output interface of the computer device is used to exchange information between the processor and the external device. The communication interface of the computer device is used for communicating with an external terminal through a network connection. The computer program, when executed by a processor, implements a method of testing a real-time operating system.
In one embodiment, a computer device is provided that includes a memory having a computer program stored therein and a processor for acquiring test tasks of a real-time operating system when the computer program is executed by the processor; distributing test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different; and merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In one embodiment, the processor, when executing the computer program, is configured to obtain the priority of each user partition; sequencing according to the priority of each user partition to obtain a sequencing result; and sequentially controlling each user partition according to the sequencing result, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
In one embodiment, when the processor executes the computer program, the processor is configured to sequentially control each user partition from the highest priority level according to the sorting result, call the memory partition corresponding to each user partition according to the allocated test task, and perform a test, so as to obtain a kernel resource scheduling log of each user partition.
In one embodiment, the processor, when executing the computer program, is configured to create a first number of user partitions for a real-time kernel of a real-time operating system after obtaining the test tasks; creating a second number of memory partitions for the memory of the real-time operating system, wherein the second number is greater than or equal to the first number; at least one memory partition is assigned to a user partition.
In one embodiment, when the processor executes the computer program, the processor is configured to allocate a test task to a first preset number of user partitions, determine a correspondence between each user partition and a test subtask, where the test task includes a plurality of test subtasks; determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition; and controlling each user partition according to the mapping table, and calling the corresponding memory partition according to the allocated test task to test.
In one embodiment, when the processor executes the computer program, the processor is configured to obtain, through the peripheral device, a result of using the memory partition, the storage resource, and the resource of the CPU in the real-time operating system in a process of controlling each user partition to invoke the memory partition corresponding to each user partition according to the allocated test task to perform a test; and obtaining a test result of the real-time operating system according to the kernel resource test result and the resource use result.
In one embodiment, a computer readable storage medium having a computer program stored thereon for acquiring test tasks of a real-time operating system when the computer program is executed by a processor is provided; distributing test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different; and merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In one embodiment, the computer program, when executed by the processor, is configured to obtain a priority of each user partition; sequencing according to the priority of each user partition to obtain a sequencing result; and sequentially controlling each user partition according to the sequencing result, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
In one embodiment, when the computer program is executed by the processor, the computer program is configured to sequentially control each user partition from the highest priority level according to the sorting result, call the memory partition corresponding to each user partition according to the allocated test task, and perform a test, so as to obtain a kernel resource scheduling log of each user partition.
In one embodiment, a computer program, when executed by a processor, is configured to create a first number of user partitions for a real-time kernel of a real-time operating system after obtaining a test task; creating a second number of memory partitions for the memory of the real-time operating system, wherein the second number is greater than or equal to the first number; at least one memory partition is assigned to a user partition.
In one embodiment, when the computer program is executed by the processor, the computer program is configured to allocate a test task to a first preset number of user partitions, determine a correspondence between each user partition and a test subtask, where the test task includes a plurality of test subtasks; determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition; and controlling each user partition according to the mapping table, and calling the corresponding memory partition according to the allocated test task to test.
In one embodiment, when the computer program is executed by the processor, the method is used for obtaining a memory partition, a storage resource and a resource use result of the CPU in the real-time operating system through the peripheral device in a process of controlling each user partition to call the memory partition corresponding to each user partition for testing according to the allocated test task; and obtaining a test result of the real-time operating system according to the kernel resource test result and the resource use result.
In one embodiment, a computer program product is provided that includes a computer program that, when executed by a processor, is configured to obtain test tasks for a real-time operating system; distributing test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different; and merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
In one embodiment, the computer program, when executed by the processor, is configured to obtain a priority of each user partition; sequencing according to the priority of each user partition to obtain a sequencing result; and sequentially controlling each user partition according to the sequencing result, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
In one embodiment, when the computer program is executed by the processor, the computer program is configured to sequentially control each user partition from the highest priority level according to the sorting result, call the memory partition corresponding to each user partition according to the allocated test task, and perform a test, so as to obtain a kernel resource scheduling log of each user partition.
In one embodiment, a computer program, when executed by a processor, is configured to create a first number of user partitions for a real-time kernel of a real-time operating system after obtaining a test task; creating a second number of memory partitions for the memory of the real-time operating system, wherein the second number is greater than or equal to the first number; at least one memory partition is assigned to a user partition.
In one embodiment, when the computer program is executed by the processor, the computer program is configured to allocate a test task to a first preset number of user partitions, determine a correspondence between each user partition and a test subtask, where the test task includes a plurality of test subtasks; determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition; and controlling each user partition according to the mapping table, and calling the corresponding memory partition according to the allocated test task to test.
In one embodiment, when the computer program is executed by the processor, the method is used for obtaining a memory partition, a storage resource and a resource use result of the CPU in the real-time operating system through the peripheral device in a process of controlling each user partition to call the memory partition corresponding to each user partition for testing according to the allocated test task; and obtaining a test result of the real-time operating system according to the kernel resource test result and the resource use result.
It should be noted that, the user information (including, but not limited to, user equipment information, user personal information, etc.) and the data (including, but not limited to, data for analysis, stored data, presented data, etc.) referred to in the present application are information and data authorized by the user or sufficiently authorized by each party, and the collection, use and processing of the related data are required to comply with the related laws and regulations and standards of the related countries and regions.
Those skilled in the art will appreciate that implementing all or part of the above described methods may be accomplished by way of a computer program stored on a non-transitory computer readable storage medium, which when executed, may comprise the steps of the embodiments of the methods described above. Any reference to memory, database, or other medium used in the various embodiments provided herein may include at least one of non-volatile and volatile memory. The nonvolatile Memory may include Read-Only Memory (ROM), magnetic tape, floppy disk, flash Memory, optical Memory, high density embedded nonvolatile Memory, resistive random access Memory (ReRAM), magnetic random access Memory (Magnetoresistive Random Access Memory, MRAM), ferroelectric Memory (Ferroelectric Random Access Memory, FRAM), phase change Memory (Phase Change Memory, PCM), graphene Memory, and the like. Volatile memory can include random access memory (Random Access Memory, RAM) or external cache memory, and the like. By way of illustration, and not limitation, RAM can be in the form of a variety of forms, such as static random access memory (Static Random Access Memory, SRAM) or dynamic random access memory (Dynamic Random Access Memory, DRAM), and the like. The databases referred to in the various embodiments provided herein may include at least one of relational databases and non-relational databases. The non-relational database may include, but is not limited to, a blockchain-based distributed database, and the like. The processors referred to in the embodiments provided herein may be general purpose processors, central processing units, graphics processors, digital signal processors, programmable logic units, quantum computing-based data processing logic units, etc., without being limited thereto.
The technical features of the above embodiments may be arbitrarily combined, and all possible combinations of the technical features in the above embodiments are not described for brevity of description, however, as long as there is no contradiction between the combinations of the technical features, they should be considered as the scope of the description.
The above examples only represent a few embodiments of the present application, which are described in more detail and are not to be construed as limiting the scope of the present application. It should be noted that it would be apparent to those skilled in the art that various modifications and improvements could be made without departing from the spirit of the present application, which would be within the scope of the present application. Accordingly, the scope of protection of the present application shall be subject to the appended claims.
Claims (10)
1. A method for testing a real-time operating system, the method comprising:
acquiring a test task of the real-time operating system;
distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different;
And merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
2. The method of claim 1, wherein the step of controlling each user partition to call a memory partition corresponding to each user partition for testing according to the allocated test task, and obtaining a kernel resource scheduling log of each user partition comprises:
acquiring the priority of each user partition;
sequencing according to the priority of each user partition to obtain a sequencing result;
and sequentially controlling each user partition according to the sequencing result, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
3. The method according to claim 2, wherein the step of sequentially controlling each user partition according to the sorting result to call a memory partition corresponding to each user partition according to the allocated test task to perform a test, and obtaining a kernel resource scheduling log of each user partition includes:
and according to the sequencing result, sequentially controlling all the user partitions from the highest priority level, calling the memory partition corresponding to each user partition according to the allocated test task to test, and obtaining the kernel resource scheduling log of each user partition.
4. The method of claim 1, wherein prior to the step of assigning the test tasks to a first predetermined number of user partitions, comprising:
after the test task is obtained, creating a first number of user partitions for a real-time kernel of the real-time operating system; creating a second number of memory partitions for the real-time operating system memory, wherein the second number is greater than or equal to the first number;
at least one memory partition is assigned to a user partition.
5. The method of claim 1, wherein the steps of allocating the test task to a first preset number of user partitions, and controlling each user partition to call a memory partition corresponding to each user partition for testing according to the allocated test task, and obtaining a kernel resource scheduling log of each user partition comprise:
distributing the test tasks to a first preset number of user partitions, and determining the corresponding relation between each user partition and the test subtasks, wherein the test tasks comprise a plurality of test subtasks;
determining the corresponding relation between each test subtask and each memory partition according to the corresponding relation between each user partition and each test subtask, and obtaining a mapping table of logical addresses-physical addresses of each test subtask according to the corresponding relation between each test subtask and each memory partition;
And controlling each user partition to call the corresponding memory partition to test according to the allocated test task according to the mapping table.
6. The method according to claim 1, wherein the method further comprises:
in the process of controlling each user partition to call a memory partition corresponding to each user partition for testing according to the allocated testing task, acquiring a memory partition, storage resources and a resource using result of a CPU in the real-time operating system through peripheral equipment;
and obtaining the test result of the real-time operating system according to the kernel resource test result and the resource use result.
7. A test apparatus for a real-time operating system, the apparatus comprising:
the acquisition module is used for acquiring the test task of the real-time operating system;
the test module is used for distributing the test tasks to a first preset number of user partitions, controlling each user partition to call a memory partition corresponding to each user partition for testing according to the distributed test tasks, and obtaining a kernel resource scheduling log of each user partition, wherein the memory partition called by each user partition is different;
and the processing module is used for merging the kernel resource scheduling logs of each user partition to obtain a kernel resource test result of the real-time operating system.
8. A computer device comprising a memory and a processor, the memory storing a computer program, characterized in that the processor implements the steps of the method of any of claims 1 to 6 when the computer program is executed.
9. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, implements the steps of the method of any of claims 1 to 6.
10. A computer program product comprising a computer program, characterized in that the computer program, when being executed by a processor, implements the steps of the method of any of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310210695.5A CN116401150A (en) | 2023-03-06 | 2023-03-06 | Method and device for testing real-time operating system, computer equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310210695.5A CN116401150A (en) | 2023-03-06 | 2023-03-06 | Method and device for testing real-time operating system, computer equipment and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116401150A true CN116401150A (en) | 2023-07-07 |
Family
ID=87016895
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310210695.5A Pending CN116401150A (en) | 2023-03-06 | 2023-03-06 | Method and device for testing real-time operating system, computer equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116401150A (en) |
-
2023
- 2023-03-06 CN CN202310210695.5A patent/CN116401150A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8381230B2 (en) | Message passing with queues and channels | |
| US9063918B2 (en) | Determining a virtual interrupt source number from a physical interrupt source number | |
| CN111770002B (en) | Test data forwarding control method and device, readable storage medium and electronic equipment | |
| CN113641457A (en) | Container creation method, device, apparatus, medium, and program product | |
| US20160378751A1 (en) | Fast query processing in columnar databases with gpus | |
| CN111831410A (en) | Task processing method and device, storage medium and electronic equipment | |
| WO2023000673A1 (en) | Hardware accelerator device management method and apparatus, and electronic device and storage medium | |
| US20210374319A1 (en) | Dynamic allocation of computing resources for electronic design automation operations | |
| CN113672375B (en) | Resource allocation prediction method, device, equipment and storage medium | |
| CN113010265A (en) | Pod scheduling method, scheduler, memory plug-in and system | |
| CN110706148A (en) | Face image processing method, device, equipment and storage medium | |
| WO2024088026A1 (en) | Cloud data migration optimization method and system | |
| CN113535087A (en) | Data processing method, server and storage system in data migration process | |
| CN111399999A (en) | Computer resource processing method and device, readable storage medium and computer equipment | |
| CN115756756A (en) | Video memory resource allocation method, device and equipment based on GPU virtualization technology | |
| CN116401150A (en) | Method and device for testing real-time operating system, computer equipment and storage medium | |
| CN115421920A (en) | Task management method and device for financial product, electronic equipment and storage medium | |
| US20140244953A1 (en) | Identifying and accessing reference data in an in-memory data grid | |
| CN115080242A (en) | Method, device and medium for unified scheduling of PCI equipment resources | |
| CN111796934B (en) | Task issuing method and device, storage medium and electronic equipment | |
| CN117093335A (en) | Task scheduling method and device for distributed storage system | |
| US9176910B2 (en) | Sending a next request to a resource before a completion interrupt for a previous request | |
| US9274837B2 (en) | Assigning levels of pools of resources to a super process having sub-processes | |
| CN113220368A (en) | Storage client resource isolation method, system, terminal and storage medium | |
| Raspopov et al. | Resource allocation algorithm modeling in queuing system based on quantization |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |