CN117012268B - Method, controller, system and medium for testing maximum performance of UFS - Google Patents
Method, controller, system and medium for testing maximum performance of UFS Download PDFInfo
- Publication number
- CN117012268B CN117012268B CN202310806120.XA CN202310806120A CN117012268B CN 117012268 B CN117012268 B CN 117012268B CN 202310806120 A CN202310806120 A CN 202310806120A CN 117012268 B CN117012268 B CN 117012268B
- Authority
- CN
- China
- Prior art keywords
- ufs
- performance
- read
- test
- write
- 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.)
- Active
Links
- 238000012360 testing method Methods 0.000 title claims abstract description 210
- 238000000034 method Methods 0.000 title claims abstract description 67
- 238000011056 performance test Methods 0.000 claims abstract description 52
- 238000011084 recovery Methods 0.000 claims abstract description 32
- 238000004590 computer program Methods 0.000 claims description 6
- 238000010998 test method Methods 0.000 abstract description 5
- 239000007787 solid Substances 0.000 description 5
- 238000012545 processing Methods 0.000 description 4
- 238000004364 calculation method Methods 0.000 description 3
- 238000010586 diagram Methods 0.000 description 3
- 230000001960 triggered effect Effects 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000004088 simulation Methods 0.000 description 2
- 238000006467 substitution reaction Methods 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000010295 mobile communication Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000007723 transport mechanism Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G11—INFORMATION STORAGE
- G11C—STATIC STORES
- G11C29/00—Checking stores for correct operation ; Subsequent repair; Testing stores during standby or offline operation
- G11C29/56—External testing equipment for static stores, e.g. automatic test equipment [ATE]; Interfaces therefor
- G11C29/56004—Pattern generation
-
- G—PHYSICS
- G11—INFORMATION STORAGE
- G11C—STATIC STORES
- G11C29/00—Checking stores for correct operation ; Subsequent repair; Testing stores during standby or offline operation
- G11C29/56—External testing equipment for static stores, e.g. automatic test equipment [ATE]; Interfaces therefor
-
- G—PHYSICS
- G11—INFORMATION STORAGE
- G11C—STATIC STORES
- G11C29/00—Checking stores for correct operation ; Subsequent repair; Testing stores during standby or offline operation
- G11C29/56—External testing equipment for static stores, e.g. automatic test equipment [ATE]; Interfaces therefor
- G11C2029/5602—Interface to device under test
-
- 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
Abstract
The embodiment of the invention provides a test method, a controller, a system and a medium for testing the maximum performance of UFS, wherein the test method comprises the steps of obtaining a test mode starting request, then entering a recovery mode of an Android system according to the test mode starting request, mounting a virtual memory disk ramdisk file system under the recovery mode, operating a flash without a process under normal conditions, and in order to prevent the flash from influencing the maximum performance of testing UFS, an application layer issues a test instruction for obtaining the performance of UFS to a kernel driving unit so that the kernel driving unit can test the performance of UFS according to the test instruction to obtain performance test data, thereby obtaining the performance test data sent by the kernel driving unit, and calculating the performance test data to obtain a test result. In the technical scheme of the implementation, other events which are not required by the test cannot be processed in the testing process of the UFS, so that the testing result of the maximum performance of the UFS can be truly obtained by testing.
Description
Technical Field
Embodiments of the present invention relate to, but are not limited to, the field of flash memory, and in particular, to a method, a controller, a system, and a medium for testing maximum performance of UFS.
Background
In the related art, the method for testing the UFS mainly uses tools such as Android and the like to test the performance of the UFS on the Android system, but after the Android system is started, other processes operate the UFS, so that the performance of the UFS test can be affected to a certain extent.
Disclosure of Invention
The embodiment of the invention provides a method, a controller, a system and a medium for testing the maximum performance of UFS, which can obtain the result of testing the maximum performance of UFS.
In order to achieve the above object, the technical solution of the embodiment of the present invention is as follows:
in a first aspect, an embodiment of the present invention provides a method for testing maximum performance of UFS, applied to an application layer, where the method includes:
acquiring a test mode starting request;
entering a recovery mode of the Android system according to the test mode starting request;
in the recovery mode, a test instruction for acquiring the performance of the UFS is issued to a kernel driving unit, so that the kernel driving unit tests the performance of the UFS according to the test instruction to obtain performance test data;
acquiring the performance test data sent by the kernel driving unit;
and calculating the performance test data to obtain a test result.
In an embodiment, the kernel driving unit tests the performance of the UFS according to the test instruction, including:
the kernel driving unit creates a cache for read-write operation according to the test instruction;
and the kernel driving unit issues a read/write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving mode.
In one embodiment, the kernel driving unit issues a read-write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving manner, including:
the kernel driving unit issues a sequential read-write command to a controller of the UFS;
and testing the UFS in a self-receiving mode according to the sequential read-write command, wherein the data size of each read/write is a first file volume, the total data amount of the read/write is a second file volume, and the second file volume is an integer multiple of the first file volume.
In one embodiment, the kernel driving unit issues a read-write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving manner, including:
the kernel driving unit issues a random read-write command to a controller of the UFS;
randomly selecting a logic block address to be started in the UFS according to the random read-write command, wherein the logic block address is aligned with the size of the third file volume;
and testing the UFS in a self-receiving mode according to the starting logical block address, wherein the data size of each read/write is the third file volume, the range of the read/write interval is set to be within zero to a fourth file volume, and the fourth file volume is an integer multiple of the third file volume.
In a second aspect, an embodiment of the present invention provides a method for testing maximum performance of UFS, applied to a kernel driving unit, where the method includes:
acquiring a test instruction of UFS performance, wherein the test instruction of UFS performance is a test instruction sent by an application layer in a recovery mode of an Android system;
testing the performance of the UFS according to the test instruction to obtain performance test data;
and sending the performance test data to the application layer so that the application layer calculates the performance test data to obtain a test result.
In an embodiment, the kernel driving unit tests the performance of the UFS according to the test instruction, including:
creating a cache for read-write operation according to the test instruction;
and issuing a read/write command to the controller of the UFS, and testing the performance of the UFS in a self-receiving mode.
In one embodiment, the kernel driving unit issues a read-write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving manner, including:
the kernel driving unit issues a sequential read-write command to a controller of the UFS;
and testing the UFS in a self-receiving mode according to the sequential read-write command, wherein the data size of each read/write is a first file volume, the total data amount of the read/write is a second file volume, and the second file volume is an integer multiple of the first file volume.
In one embodiment, the kernel driving unit issues a read-write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving manner, including:
issuing a random read-write command to a controller of the UFS;
randomly selecting a logic block address to be started in the UFS according to the random read-write command, wherein the logic block address is aligned with the size of the third file volume;
and testing the UFS in a self-receiving mode according to the starting logical block address, wherein the data size of each read/write is the third file volume, the range of the read/write interval is set to be within zero to a fourth file volume, and the fourth file volume is an integer multiple of the third file volume.
In a third aspect, embodiments of the present invention also provide a controller comprising a processor and a memory for storing a computer program capable of running on the processor; wherein the processor is configured to execute the steps of the testing method for maximum performance of UFS according to the first aspect or the second aspect when running the computer program.
In a fourth aspect, embodiments of the present invention also provide a computer storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the testing method of the first aspect or the second aspect for maximum performance of UFS.
The embodiment of the invention provides a method, a controller, equipment and a medium for testing the maximum performance of UFS, wherein the method for testing the maximum performance of UFS comprises the steps of acquiring a test mode starting request, then entering a recovery mode of an Android system according to the test mode starting request, and under the recovery mode, mounting a virtual memory disk file system, normally operating a flash without a process, and in order to prevent the flash from influencing the maximum performance of testing the UFS, an application layer issues a test instruction for acquiring the UFS performance to a kernel driving unit so that the kernel driving unit tests the performance of the UFS according to the test instruction to obtain performance test data, thereby acquiring the performance test data sent by the kernel driving unit, and processing the performance test data to obtain a test result. In the technical scheme of the implementation, the Android system is abnormally started in the process of starting up the terminal, and enters a recovery mode, and a test instruction for acquiring the performance of the UFS is issued to the kernel driving unit through the application layer in the recovery mode, so that the performance of the UFS is tested, other events which are not required by the test cannot be processed in the testing process of the UFS, and the test result of the maximum performance of the UFS can be truly tested.
Drawings
Fig. 1 is a schematic diagram of a system architecture platform for performing a method for testing maximum performance of UFS according to an embodiment of the present invention;
fig. 2 is a flowchart of a method for testing maximum performance of UFS applied to an application layer according to an embodiment of the present invention;
fig. 3 is a flowchart of a method for testing the maximum performance of the UFS applied to the kernel driving unit according to another embodiment of the present invention.
Detailed Description
The present invention will be described in further detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present invention more apparent. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the invention.
It should be noted that although functional block division is performed in a device diagram and a logic sequence is shown in a flowchart, in some cases, the steps shown or described may be performed in a different order than the block division in the device, or in the flowchart. The terms first, second and the like in the description, in the claims and in the above-described figures, are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order.
The game test of Solid State Disk (Solid State Drive, abbreviated as SSD) generally needs to connect with a specific terminal, then a simulation test is performed through a system platform of the terminal, different types of operations are required to be performed on a specific game in the simulation process, specific game operation data are obtained, and therefore in the game operation process, the Solid State Disk is tested to obtain a test result, but the game is required to be actually operated in the test process, so that the test efficiency is lower.
In order to solve the problem of the decrease of the reliability of the flash memory, the embodiment of the invention provides a method, a controller, a device and a medium for testing the maximum performance of the UFS. In the technical scheme of the implementation, the Android system is abnormally started in the process of starting up the terminal, and enters a recovery mode, and a test instruction for acquiring the performance of the UFS is issued to the kernel driving unit through the application layer in the recovery mode, so that the performance of the UFS is tested, other events which are not required by the test can not be processed in the testing process of the UFS, and the testing result of the maximum performance of the UFS can be truly tested.
Embodiments of the present invention will be further described below with reference to the accompanying drawings.
Fig. 1 is a schematic diagram of a system platform architecture for performing a method for testing the maximum performance of UFS according to an embodiment of the present invention.
In the example of fig. 1, the system platform architecture 100 is provided with a processor 110 and a memory 120, wherein the processor 110 and the memory 120 may be connected by a bus or otherwise, in fig. 1 by way of example.
Memory 120, as a non-transitory computer-readable storage medium, may be used to store non-transitory software programs as well as non-transitory computer-executable programs. In addition, memory 120 may include high-speed random access memory, and may also include non-transitory memory, such as at least one magnetic disk storage device, flash memory device, or other non-transitory solid state storage device. In some embodiments, memory 120 optionally includes memory remotely located with respect to processor 110, which may be connected to a test device for maximum performance of the UFS via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
It will be appreciated by those skilled in the art that the system platform architecture 100 may be applied to a flash memory chip, a later-developed memory unit, etc., and the present embodiment is not limited thereto.
Those skilled in the art will appreciate that the system platform architecture 100 shown in fig. 1 is not limiting of the embodiments of the invention, and may include more or fewer components than shown, or may combine certain components, or a different arrangement of components.
Based on the system platform architecture shown in fig. 1, various embodiments of the method for testing UFS maximum performance of the present invention are set forth below.
As shown in fig. 2, fig. 2 is a flowchart of a method for testing the maximum performance of the UFS based on the device testing system shown in fig. 1 according to an embodiment of the present invention, where the method for testing the maximum performance of the UFS applied to the application layer according to the embodiment of the present invention may include, but is not limited to, step S100, step S200, step S300, step S400, and step S500.
Step S100, a test mode starting request is obtained.
Specifically, when the UFS needs to be tested, the closed terminal needs to be started, and then the user can trigger a test mode starting request according to a preset input instruction, and then the terminal can acquire the test mode starting request.
It should be noted that, the triggering test mode starting request may be triggered by pressing a single physical button, or may be triggered by pressing a combination of physical buttons, or may be triggered by inputting an instruction to the terminal through a master of the test platform, which is not specifically limited in this embodiment.
Step S200, entering a recovery mode of the Android system according to the test mode starting request.
Specifically, after the test mode starting request is obtained, the application layer enters a recovery mode of the Android system according to the test mode starting request, and the Android system is not started normally any more, so that the accuracy of the maximum performance test of the UFS can be prevented from being influenced by a process generated in the starting process of the Android system or after the starting process.
And step S300, in the recovery mode, issuing a test instruction for acquiring the performance of the UFS to the kernel driving unit so that the kernel driving unit tests the performance of the UFS according to the test instruction to obtain performance test data.
Specifically, in the recovery mode, since the virtual memory disk file system is mounted in the recovery mode, if no process is performed in the recovery mode, the recovery mode can operate the flash related process, so that in order to prevent the impact of the flash related process on the accuracy of the maximum performance test of the UFS, the recovery mode needs to be interfered, and after the recovery mode is entered, an application layer is set to immediately issue a test instruction for acquiring the performance of the UFS to the kernel driving unit, so that the kernel driving unit can test the performance of the UFS according to the test instruction to obtain performance test data, and thus, not only can the test instruction be sent to the kernel driving unit, but also the triggering of the flash related process can be prevented.
Step S400, performance test data sent by a kernel driving unit are obtained.
Specifically, the kernel driving unit sends the performance test data obtained in the performance test process of the UFS to the application layer, so that the application layer can obtain the performance test data and store the performance test data.
And S500, performing calculation processing on the performance test data to obtain a test result.
Specifically, the application layer can immediately perform calculation analysis processing on the performance test data after receiving the performance test data to obtain a performance test result, for example, the total time required by sequentially reading and writing data of a plurality of target file volumes through calculation; for example by calculating the total time required to randomly read and write data for a plurality of target file volumes.
In some alternative embodiments, a test mode starting request is obtained first, then a recovery mode of the Android system is entered according to the test mode starting request, a virtual memory disk file system is mounted in the recovery mode, then a flash is operated under normal conditions without a process, in order to prevent the flash from influencing the maximum performance of testing the UFS, an application layer issues a test instruction for obtaining the performance of the UFS to a kernel driving unit, so that the kernel driving unit tests the performance of the UFS according to the test instruction to obtain performance test data, and therefore performance test data sent from the kernel driving unit can be obtained, and the performance test data are processed to obtain a test result. In the technical scheme of the implementation, the Android system is abnormally started in the process of starting up the terminal, and enters a recovery mode, and a test instruction for acquiring the performance of the UFS is issued to the kernel driving unit through the application layer in the recovery mode, so that the performance of the UFS is tested, other events which are not required by the test can not be processed in the testing process of the UFS, and the testing result of the maximum performance of the UFS can be truly tested.
In some alternative embodiments, the kernel driving unit in step S300 may test performance of the UFS according to the test instruction, including: the kernel driving unit firstly creates a buffer memory for read-write operation according to the test instruction, then issues a read/write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving mode.
In some alternative embodiments, the test instruction characterizes performance test of sequential reading and writing to the UFS, and then the kernel driving unit may issue a sequential reading and writing command to the controller of the UFS according to the test instruction, and test the UFS in a form of self-receiving according to the sequential reading and writing command, where a data size of each reading/writing is a first file volume, a total amount of data read/written together is a second file volume, and the second file volume is an integer multiple of the first file volume. For example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, spontaneously receives and tests the performance of the UFS, returns performance test data to the application layer, and sequentially reads and writes the requirements: each read/write is 512KB (first file volume) data, a total of 512M (second file volume) is read/written, and then the total time is calculated through an application layer, so that a test result for calculating the maximum performance of the UFS is obtained. Also for example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, tests the performance of the UFS, returns performance test data to the application layer, and sequentially reads and writes the requirements: each time of reading/writing is 256KB (first file volume) data, 1GB (second file volume) is read/written in total, and then the total time is calculated through an application layer, so that a test result for calculating the maximum performance of the UFS is obtained.
In some alternative embodiments, the test instruction characterizes a performance test of random reading and writing to the UFS, and then the kernel driving unit issues a random reading and writing command to the controller of the UFS; according to the random read-write command, randomly selecting a starting logical block address in the UFS, wherein the logical block address is aligned with the size of the third file volume; and testing the UFS in a self-receiving mode according to the starting logical block address, wherein the data size of each read/write is a third file volume, the range of the read/write interval is set to be zero to be within a fourth file volume, and the fourth file volume is an integer multiple of the third file volume. For example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, spontaneously receives, tests the performance of the UFS, and returns performance test data to the application layer, wherein the random read-write requirements are as follows: every time the data is read/written into 4KB (third file volume), the interval is 0-512MB (fourth file volume), the starting logical block address is randomly selected, the address and 4K are required to be used for the data, 131072 pens (512 MB/4KB pens) are written in total, the total time is calculated, and the performance is calculated. Also for example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, spontaneously receives, tests the performance of the UFS, and returns performance test data to the application layer, wherein the random read-write requirements are as follows: each time of reading/writing is 8KB (third file volume) data, the interval is 0-1GB (fourth file volume), the starting logical block address is randomly selected, the address and 8KB are used for the starting logical block address, 131072 pens (1 GB/8KB pens) are written in total, the total time is calculated, and the performance is calculated.
As shown in fig. 3, fig. 3 is a flowchart of a method for testing the maximum performance of UFS according to another embodiment of the present invention, where the method for testing the maximum performance of UFS applied to a kernel driving unit according to an embodiment of the present invention may include, but is not limited to, step S310, step S320, step S330, step S340, and step S350.
Step S310, obtaining a test instruction of UFS performance, wherein the test instruction of UFS performance is a test instruction sent by an application layer in a recovery mode of an Android system;
step S320, testing the performance of the UFS according to the test instruction to obtain performance test data;
step S330, the performance test data is sent to the application layer, so that the application layer calculates the performance test data to obtain a test result.
Specifically, a test mode starting request is firstly obtained, then a recovery mode of an Android system is entered according to the test mode starting request, a virtual memory disk file system is mounted in the recovery mode, then a flash is operated without a process under normal conditions, in order to prevent the flash from influencing the maximum performance of a test UFS, an application layer issues a test instruction for obtaining the performance of the UFS to a kernel driving unit, the kernel driving unit tests the performance of the UFS according to the test instruction to obtain performance test data, and accordingly the performance test data sent by the kernel driving unit can be obtained, and the performance test data are processed to obtain a test result. In the technical scheme of the implementation, the Android system is not normally started in the starting process of the terminal, and the terminal enters a recovery mode. In the recovery mode, the kernel driving unit tests the performance of the UFS according to the test instruction of the UFS performance obtained from the application layer, so that other events which are not required by the test cannot be processed in the testing process of the UFS, and the test result of the maximum performance of the UFS can be truly obtained by testing.
In some alternative embodiments, the kernel driving unit testing the performance of the UFS according to the test instruction in step S310 may include: the kernel driving unit firstly creates a buffer memory for read-write operation according to the test instruction, then issues a read/write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving mode.
In some alternative embodiments, the test instruction characterizes performance test of sequential reading and writing to the UFS, and then the kernel driving unit may issue a sequential reading and writing command to the controller of the UFS according to the test instruction, and test the UFS in a form of self-receiving according to the sequential reading and writing command, where a data size of each reading/writing is a first file volume, a total amount of data read/written together is a second file volume, and the second file volume is an integer multiple of the first file volume. For example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, spontaneously receives and tests the performance of the UFS, returns performance test data to the application layer, and sequentially reads and writes the requirements: each read/write is 512KB (first file volume) data, a total of 512M (second file volume) is read/written, and then the total time is calculated through an application layer, so that a test result for calculating the maximum performance of the UFS is obtained. Also for example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, tests the performance of the UFS, returns performance test data to the application layer, and sequentially reads and writes the requirements: each time of reading/writing is 256KB (first file volume) data, 1GB (second file volume) is read/written in total, and then the total time is calculated through an application layer, so that a test result for calculating the maximum performance of the UFS is obtained.
In some alternative embodiments, the test instruction characterizes a performance test of random reading and writing to the UFS, and then the kernel driving unit issues a random reading and writing command to the controller of the UFS; according to the random read-write command, randomly selecting a starting logical block address in the UFS, wherein the logical block address is aligned with the size of the third file volume; and testing the UFS in a self-receiving mode according to the starting logical block address, wherein the data size of each read/write is a third file volume, the range of the read/write interval is set to be zero to be within a fourth file volume, and the fourth file volume is an integer multiple of the third file volume. For example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, spontaneously receives, tests the performance of the UFS, and returns performance test data to the application layer, wherein the random read-write requirements are as follows: every time the data is read/written into 4KB (third file volume), the interval is 0-512MB (fourth file volume), the starting logical block address is randomly selected, the address and 4K are required to be used for the data, 131072 pens (512 MB/4KB pens) are written in total, the total time is calculated, and the performance is calculated. Also for example: after receiving the test instruction, the kernel driving unit creates a buffer space required by the read-write test, then directly operates the UFS controller of the host, issues a sequential read/write command, spontaneously receives, tests the performance of the UFS, and returns performance test data to the application layer, wherein the random read-write requirements are as follows: each time of reading/writing is 8KB (third file volume) data, the interval is 0-1GB (fourth file volume), the starting logical block address is randomly selected, the address and 8KB are used for the starting logical block address, 131072 pens (1 GB/8KB pens) are written in total, the total time is calculated, and the performance is calculated.
In addition, one embodiment of the present invention provides a controller 100 provided with a processor 110 and a memory 120, wherein the processor 110 and the memory 120 may be connected by a bus or otherwise, as exemplified by the bus connection in fig. 1.
Memory 120 is a schematic readable storage medium of a system platform architecture for performing a method of testing maximum performance of UFS provided by one embodiment of the present invention as a non-transitory computer, and may be used to store non-transitory software programs as well as non-transitory computer-executable programs. In addition, memory 120 may include high-speed random access memory, and may also include non-transitory memory, such as at least one magnetic disk storage device, flash memory device, or other non-transitory solid state storage device. In some implementations, the memory 120 optionally includes memory that is remotely located relative to the processor 110.
The controller 100 is capable of storing in a memory a non-transitory software program and instructions required for implementing the method of testing for UFS maximum performance of the above-described embodiment, which when executed by a processor, performs the method of testing for UFS maximum performance of the above-described embodiment, for example, performing the method steps S100 to S500 in fig. 2, and the method steps S310 to S330 in fig. 3 described above.
Furthermore, an embodiment of the present invention provides a computer-readable storage medium storing computer-executable instructions for performing the method for testing the maximum performance of UFS of the controller described above, for example, performing the method steps S100 to S500 in fig. 2 and the method steps S310 to S330 in fig. 3 described above.
Those of ordinary skill in the art will appreciate that all or some of the steps, systems, and methods disclosed above may be implemented as software, firmware, hardware, and suitable combinations thereof. Some or all of the physical components may be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application specific integrated circuit. Such software may be distributed on computer readable media, which may include computer storage media (or non-transitory media) and communication media (or transitory media). The term computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data, as known to those skilled in the art. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital Versatile Disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by a computer. Furthermore, as is well known to those of ordinary skill in the art, communication media typically include computer readable instructions, data structures, program modules, or other data in a modulated data signal, such as a carrier wave or other transport mechanism, and may include any information delivery media.
While the preferred embodiment of the present invention has been described in detail, the present invention is not limited to the above embodiments, and those skilled in the art can make various equivalent modifications or substitutions without departing from the spirit and scope of the present invention, and these equivalent modifications or substitutions are included in the scope of the present invention as defined in the appended claims.
Claims (10)
1. A method for testing maximum performance of UFS, applied to an application layer, said method comprising:
acquiring a test mode starting request;
entering a recovery mode of the Android system according to the test mode starting request;
in the recovery mode, a test instruction for acquiring the performance of the UFS is issued to a kernel driving unit, so that the kernel driving unit tests the performance of the UFS according to the test instruction to obtain performance test data;
acquiring the performance test data sent by the kernel driving unit;
and calculating the performance test data to obtain a test result.
2. The method of claim 1, wherein the kernel driver unit testing performance of the UFS according to the test instruction comprises:
the kernel driving unit creates a cache for read-write operation according to the test instruction;
and the kernel driving unit issues a read/write command to the controller of the UFS, and tests the performance of the UFS in a self-receiving mode.
3. The method of claim 2, wherein the kernel driver unit issues read/write commands to a controller of the UFS and tests performance of the UFS in a self-contained form, comprising:
the kernel driving unit issues a sequential read-write command to a controller of the UFS;
and testing the UFS in a self-receiving mode according to the sequential read-write command, wherein the data size of each read/write is a first file volume, the total data amount of the read/write is a second file volume, and the second file volume is an integer multiple of the first file volume.
4. The method of claim 2, wherein the kernel driver unit issues read/write commands to a controller of the UFS and tests performance of the UFS in a self-contained form, comprising:
the kernel driving unit issues a random read-write command to a controller of the UFS;
randomly selecting a logic block address to be started in the UFS according to the random read-write command, wherein the logic block address is aligned with the size of the third file volume;
and testing the UFS in a self-receiving mode according to the logical block address, wherein the data size of each read/write is the third file volume, the range of the read/write interval is set to be between zero and a fourth file volume, and the fourth file volume is an integer multiple of the third file volume.
5. A method for testing the maximum performance of a UFS, applied to a kernel driver unit, said method comprising:
acquiring a test instruction of UFS performance, wherein the test instruction of UFS performance is a test instruction sent by an application layer in a recovery mode of an Android system;
testing the performance of the UFS according to the test instruction to obtain performance test data;
and sending the performance test data to the application layer so that the application layer calculates the performance test data to obtain a test result.
6. The method of claim 5, wherein the kernel driver unit testing the performance of the UFS based on the test instruction, comprising:
creating a cache for read-write operation according to the test instruction;
and issuing a read/write command to the controller of the UFS, and testing the performance of the UFS in a self-receiving mode.
7. The method of claim 6, wherein the kernel driver unit issues read/write commands to a controller of the UFS and tests performance of the UFS in a self-contained form, comprising:
the kernel driving unit issues a sequential read-write command to a controller of the UFS;
and testing the UFS in a self-receiving mode according to the sequential read-write command, wherein the data size of each read/write is a first file volume, the total data amount of the read/write is a second file volume, and the second file volume is an integer multiple of the first file volume.
8. The method of claim 6, wherein the kernel driver unit issues read/write commands to a controller of the UFS and tests performance of the UFS in a self-contained form, comprising:
issuing a random read-write command to a controller of the UFS;
randomly selecting a logic block address to be started in the UFS according to the random read-write command, wherein the logic block address is aligned with the size of the third file volume;
and testing the UFS in a self-receiving mode according to the logical block address, wherein the data size of each read/write is the third file volume, the range of the read/write interval is set to be between zero and a fourth file volume, and the fourth file volume is an integer multiple of the third file volume.
9. A test apparatus comprising a processor and a memory for storing a computer program capable of running on the processor; wherein the processor is adapted to perform the steps of the method of any of claims 1 to 4 or the steps of the method of any of claims 5 to 8 when the computer program is run.
10. A computer storage medium having stored thereon a computer program, which when executed by a processor performs the steps of the method according to any of claims 1 to 4 or performs the steps of the method according to any of claims 5 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310806120.XA CN117012268B (en) | 2023-06-30 | 2023-06-30 | Method, controller, system and medium for testing maximum performance of UFS |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310806120.XA CN117012268B (en) | 2023-06-30 | 2023-06-30 | Method, controller, system and medium for testing maximum performance of UFS |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117012268A CN117012268A (en) | 2023-11-07 |
| CN117012268B true CN117012268B (en) | 2024-03-19 |
Family
ID=88573610
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310806120.XA Active CN117012268B (en) | 2023-06-30 | 2023-06-30 | Method, controller, system and medium for testing maximum performance of UFS |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117012268B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117472294B (en) * | 2023-12-28 | 2024-04-09 | 合肥康芯威存储技术有限公司 | Memory and data processing method thereof |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108508349A (en) * | 2018-03-16 | 2018-09-07 | 广州视源电子科技股份有限公司 | Board stored response testing method, system, storage medium and computer equipment |
| CN108959055A (en) * | 2018-07-25 | 2018-12-07 | 郑州云海信息技术有限公司 | Readwrite performance test method, device and the equipment of xfs file system |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR102564774B1 (en) * | 2018-09-18 | 2023-08-09 | 에스케이하이닉스 주식회사 | Apparatus for diagnosing memory system or data processing system and operating method of memory system or data processing system based on diagnosis |
-
2023
- 2023-06-30 CN CN202310806120.XA patent/CN117012268B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108508349A (en) * | 2018-03-16 | 2018-09-07 | 广州视源电子科技股份有限公司 | Board stored response testing method, system, storage medium and computer equipment |
| CN108959055A (en) * | 2018-07-25 | 2018-12-07 | 郑州云海信息技术有限公司 | Readwrite performance test method, device and the equipment of xfs file system |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117012268A (en) | 2023-11-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108459826B (en) | Method and device for processing IO (input/output) request | |
| US8996768B2 (en) | Method and storage device for assessing execution of trim commands | |
| CN117012268B (en) | Method, controller, system and medium for testing maximum performance of UFS | |
| KR20140060308A (en) | Efficient access to storage devices with usage bitmaps | |
| US9983826B2 (en) | Data storage device deferred secure delete | |
| CN113625973B (en) | Data writing method, device, electronic equipment and computer readable storage medium | |
| CN112017723A (en) | Power failure test method and device for memory, readable storage medium and electronic equipment | |
| CN114518981A (en) | eMMC test method, device, readable storage medium and electronic equipment | |
| CN110083305B (en) | Memory system and operating method thereof | |
| CN104133640B (en) | From the fast quick-recovery of dormancy | |
| CN112133357B (en) | eMMC test method and device | |
| CN117012267B (en) | Verification method, controller and medium for UFS written data | |
| US20050107987A1 (en) | System and method for testing a memory with an expansion card using DMA | |
| KR20190060424A (en) | Memory system for error test | |
| CN112417802B (en) | Method, system, equipment and storage medium for simulating storage chip | |
| CN114924923A (en) | Method, system, equipment and medium for verifying correctness of hard disk write-in point | |
| CN113948146A (en) | Test method and device for solid state disk and electronic equipment | |
| US20110296119A1 (en) | Stored Data Reading Apparatus, Method and Computer Apparatus | |
| US8953393B2 (en) | Semiconductor device and operating method thereof | |
| JP6740773B2 (en) | Information processing apparatus, program, and information processing method | |
| US20160077942A1 (en) | Storage system and test method for testing pci express interface | |
| CN111459848A (en) | File fragment sorting method and device, storage medium and electronic equipment | |
| CN111949561B (en) | Storage device, control method and control device thereof | |
| CN112416675B (en) | Capacity expansion detection method and device for memory | |
| CN110968441B (en) | Memory card access device and method |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |