CN113076233A - IO performance detection method, device, equipment and storage medium - Google Patents
IO performance detection method, device, equipment and storage medium Download PDFInfo
- Publication number
- CN113076233A CN113076233A CN202110338422.XA CN202110338422A CN113076233A CN 113076233 A CN113076233 A CN 113076233A CN 202110338422 A CN202110338422 A CN 202110338422A CN 113076233 A CN113076233 A CN 113076233A
- Authority
- CN
- China
- Prior art keywords
- file
- function
- performance
- determining
- calling function
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000001514 detection method Methods 0.000 title claims abstract description 117
- 238000000034 method Methods 0.000 claims abstract description 73
- 239000000523 sample Substances 0.000 claims abstract description 73
- 238000012544 monitoring process Methods 0.000 claims abstract description 69
- 238000012545 processing Methods 0.000 claims abstract description 44
- 230000006870 function Effects 0.000 claims description 263
- 230000015654 memory Effects 0.000 claims description 36
- 230000008569 process Effects 0.000 claims description 31
- 238000004590 computer program Methods 0.000 claims description 7
- 238000010586 diagram Methods 0.000 description 14
- 238000005457 optimization Methods 0.000 description 13
- 238000004891 communication Methods 0.000 description 8
- 238000005516 engineering process Methods 0.000 description 7
- 230000007246 mechanism Effects 0.000 description 5
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 238000010276 construction Methods 0.000 description 2
- 238000003780 insertion Methods 0.000 description 2
- 230000037431 insertion Effects 0.000 description 2
- 238000009434 installation Methods 0.000 description 2
- 230000010354 integration Effects 0.000 description 2
- 238000004806 packaging method and process Methods 0.000 description 2
- 238000012856 packing Methods 0.000 description 2
- 238000011895 specific detection Methods 0.000 description 2
- 238000012360 testing method Methods 0.000 description 2
- 230000006399 behavior Effects 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000005265 energy consumption Methods 0.000 description 1
- 238000000605 extraction Methods 0.000 description 1
- 239000011521 glass Substances 0.000 description 1
- 230000014759 maintenance of location Effects 0.000 description 1
- 239000000463 material Substances 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
- 238000011160 research Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 238000012546 transfer 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/30—Monitoring
- G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
- G06F11/3041—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system component is an input/output interface
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3058—Monitoring arrangements for monitoring environmental properties or parameters of the computing system or of the computing system component, e.g. monitoring of power, currents, temperature, humidity, position, vibrations
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3089—Monitoring arrangements determined by the means or processing involved in sensing the monitored data, e.g. interfaces, connectors, sensors, probes, agents
- G06F11/3093—Configuration details thereof, e.g. installation, enabling, spatial arrangement of the probes
-
- 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 text belongs to the field of automatic program design, and particularly relates to an IO performance detection method, an IO performance detection device, IO performance detection equipment and a storage medium, wherein the method comprises the following steps: when IO operation is detected, determining a target calling function corresponding to the IO operation; determining a probe function corresponding to the target calling function; obtaining IO performance parameters of the target calling function during operation through the probe function; according to the preset detection strategy, the IO performance parameters are subjected to performance detection processing, the calling function during IO operation is monitored through the probe function, the IO performance parameters can be quickly obtained, meanwhile, the performance influence on a detection target can be reduced, the reliability of IO performance detection is improved, meanwhile, the monitoring while various monitoring indexes can be realized by combining different preset detection strategies, and the performance condition during IO operation is comprehensively reflected.
Description
Technical Field
The present disclosure relates to the field of automatic programming, and in particular, to an IO performance detection method, apparatus, device, and storage medium.
Background
With the increasing application scenes of intelligent terminals (such as mobile phones), the types of online mobile applications are increasing, and various applications are used for storing various data, such as databases and configuration files, on the intelligent terminals, and video applications are more required to store video files and audio files. Storing data files in a memory of a mobile phone involves I/O operation, if the I/O operation is unreasonable (for example, the read-write mode is set unreasonable), a large amount of read-write can cause the service life of a flash memory of the mobile phone to be shortened, so that an application is blocked, and unreasonable cross-process read-write can cause risks of data loss and damage, thereby not only affecting user experience, but also causing a large amount of loss of users.
When a mobile terminal developer performs performance optimization, I/O optimization is performed in addition to CPU optimization, network optimization and memory optimization, and currently, monitoring codes are mainly inserted into a system side of an application program for I/O optimization, but this way reduces the running efficiency of the application program and cannot reflect the real running condition of the application program, so that a reliable, stable and low-performance-loss online I/O monitoring system is lacking at present, and further effective and reliable I/O monitoring cannot be performed.
Disclosure of Invention
In view of the foregoing problems in the prior art, it is an object of the present disclosure to provide an IO performance detection method, apparatus, device and storage medium to reduce performance loss during I/O monitoring, so as to provide effective and reliable I/O performance monitoring.
In order to solve the technical problems, the specific technical scheme is as follows:
in one aspect, an input/output (IO) performance detection method is provided herein, where the method includes:
when IO operation is detected, determining a target calling function corresponding to the IO operation;
determining a probe function corresponding to the target calling function;
obtaining IO performance parameters of the target calling function during operation through the probe function;
and performing performance detection processing on the IO performance parameters according to a preset detection strategy.
Further, the determining the probe function corresponding to the target call function includes:
acquiring a pre-configured relation corresponding table of a calling function and a probe function;
further, the relationship correspondence table is obtained by:
determining a target object to be detected;
determining a calling function corresponding to the target object to be detected according to the target object to be detected;
determining the position of the calling function in a corresponding calling function library according to the calling function;
according to the position of the calling function, performing instrumentation processing on the calling function according to a preset instrumentation rule to obtain a probe function corresponding to the calling function;
and generating the relation corresponding table according to the position relation of the probe function and the calling function.
Further, the determining, according to the target object to be detected, a call function corresponding to the target object to be detected includes:
acquiring system version information of a target object to be detected;
and determining a calling function according to the target object to be detected and the system version information.
Optionally, the performing instrumentation processing on the call function according to a preset instrumentation rule according to the position of the call function includes:
determining a calling code segment of the calling function according to the position of the calling function;
and inserting a probe code segment into a preset position of the calling code segment of the calling function to obtain a probe function, so that the probe function obtains IO performance parameters when the calling function runs.
Optionally, the probe function is a hook function.
Further, the target call function includes at least one of: an open function, a read function, a write function, and a close function;
the opening function is used for acquiring a file name, a file descriptor, an initial size of a file, stack information and thread information when the file is opened;
the reading function is used for acquiring the file type, the file content, the file reading mode, the file reading times, the total size of the read file, the Buffer size used in the file reading and the total time consumption of the reading process when the file is read;
the writing function is used for acquiring the file type and the file content when the file is written, the file writing mode, the file writing times, the total size of the written file, the Buffer size used when the file is written and the total time consumption of the writing process;
the closing function is used for acquiring the total time consumption of file opening and the maximum continuous reading and writing time.
Optionally, the probe function is further configured to obtain a CPU utilization rate and memory utilization information of the target object to be detected during operation.
Further, the processing the IO performance parameter according to a preset detection policy further includes:
and sending the IO performance parameters to a monitoring platform so that the monitoring platform displays the IO performance parameters, and analyzing the IO performance parameters according to the preset detection strategy.
Optionally, the preset detection policy includes a thread early warning policy, a Buffer size monitoring policy, a file monitoring policy, and a resource leakage monitoring policy.
Further, when the preset detection policy is a thread early warning policy, the performing performance detection processing on the IO performance parameter according to the preset detection policy includes:
acquiring the thread information during the IO operation;
judging whether the IO operation runs a main thread or not according to the thread information;
and if the IO operation runs in the main thread, generating early warning information.
Further, when the preset detection policy is a Buffer size monitoring policy, the performing, according to the preset detection policy, performance detection processing on the IO performance parameter includes:
acquiring the total size of a read or write file, and judging whether the total size of the file exceeds a file size threshold value;
when the total size of the file exceeds the file size threshold, acquiring the number of times of reading or writing the file;
calculating the size of a Buffer used when the file is read or written according to the total size of the read or write file and the number of times of reading or writing;
judging whether the reading or writing times of the file exceed a time threshold value and/or whether the size of the Buffer is smaller than a Buffer size threshold value;
and generating early warning information when the reading or writing times of the file exceed a time threshold value and/or the size of the Buffer is smaller than a Buffer size threshold value.
Optionally, the obtaining a total size of the read or write file, and determining whether the total size of the file exceeds a file size threshold, further includes:
when the total size of the file exceeds the file size threshold, acquiring a file reading or writing mode;
and when the file reading or writing mode is a first mode, generating early warning information, wherein the first mode is an output stream mode according to an object.
Further, when the preset detection policy is a file monitoring policy, the performing, according to the preset detection policy, performance detection processing on the IO performance parameter includes:
acquiring file names of a plurality of opened files, and judging whether files with the same file name exist or not;
when at least two files with the same file name exist, acquiring file contents of the at least two files;
when the file contents of the at least two files are the same, reading the file contents of the at least two files within a first preset time through the reading function;
and judging whether the file contents of the at least two files are updated or not, and if not, generating early warning information.
Further, when the preset detection policy is a resource leakage monitoring policy, the performing, according to the preset detection policy, performance detection processing on the IO performance parameter includes:
determining a file opened by the opening function;
traversing the files opened by the opening function within a second preset time period, and judging whether the files which are not closed by the closing function exist or not;
and when the file which is not closed by the closing function exists, generating early warning information.
In another aspect, this document also provides an IO performance detection apparatus, including:
the target calling function determining module is used for determining a target calling function corresponding to the IO operation when the IO operation is detected;
the probe function determining module is used for determining a probe function corresponding to the target calling function;
an IO performance parameter obtaining module, configured to obtain, through the probe function, an IO performance parameter when the target call function operates;
and the performance detection module is used for carrying out performance detection processing on the IO performance parameters according to a preset detection strategy.
In another aspect, a computer device is also provided herein, comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the method steps as described above when executing the computer program.
Finally, a computer-readable storage medium is also provided herein, which stores a computer program that, when executed by a processor, carries out the method steps as described above.
By adopting the technical scheme, the IO performance detection method, the device, the equipment and the storage medium, which are disclosed herein, monitor the call function during IO operation through the probe function, can realize quick acquisition of IO performance parameters, can reduce the performance influence on a detection target, improve the reliability of IO performance detection, and simultaneously, monitor various monitoring indexes simultaneously by combining different preset detection strategies, so that the performance condition during IO operation can be comprehensively reflected.
In order to make the aforementioned and other objects, features and advantages of the present invention comprehensible, preferred embodiments accompanied with figures are described in detail below.
Drawings
In order to more clearly illustrate the embodiments or technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art that other drawings can be obtained according to the drawings without creative efforts.
Fig. 1 is a schematic diagram illustrating an application environment of an IO performance detection method provided in an embodiment of the present disclosure;
fig. 2 is a schematic diagram illustrating steps of an IO performance detection method provided in an embodiment herein;
FIG. 3 is a schematic diagram showing the probe function determination step in the examples herein;
FIG. 4 is a diagram showing the pre-configuration of probe functions in the examples herein;
FIG. 5 is a schematic diagram illustrating thread monitoring policy steps in an embodiment herein;
FIG. 6 is a diagram illustrating the steps of a Buffer size monitoring policy in an embodiment of the present disclosure;
FIG. 7 is a diagram illustrating the steps of a file monitoring policy in an embodiment herein;
FIG. 8 is a diagram illustrating resource leakage monitoring policy steps in an embodiment herein;
FIG. 9 is a diagram illustrating classification of preset detection strategies in an embodiment of the present disclosure;
FIG. 10 is a schematic diagram illustrating an implementation flow of the IO performance detection method in the embodiment herein;
fig. 11 shows a schematic structural diagram of an IO performance detection apparatus provided in an embodiment herein;
fig. 12 shows a schematic structural diagram of a computer device provided in embodiments herein.
Description of the symbols of the drawings:
10. an intelligent terminal;
20. a monitoring platform;
100. a target call function determination module;
200. a probe function determination module;
300. an IO performance parameter acquisition module;
400. a performance detection module;
1202. a computer device;
1204. a processor;
1206. a memory;
1208. a drive mechanism;
1210. an input/output module;
1212. an input device;
1214. an output device;
1216. a presentation device;
1218. a graphical user interface;
1220. a network interface;
1222. a communication link;
1224. a communication bus.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments herein without making any creative effort, shall fall within the scope of protection.
It should be noted that the terms "first," "second," and the like in the description and claims herein and in the above-described drawings are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments herein described are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, apparatus, article, or device that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or device.
Before the embodiments of the present specification are explained, terms used herein will be explained as follows:
the magnetic disk is a storage device of the system, is similar to a CD or a mechanical hard disk used by a computer, and is also a conventional SSD solid state disk.
A file system, in short, is the way data is stored and organized. For Android, the ext4 file system commonly used in Linux is commonly used at present.
JVM, an abbreviation of Java Virtual Machine, is a specification for computing devices, which is an imaginary computer implemented by emulating and simulating various computer functions on a real computer. After the Java language virtual machine is introduced, the Java language does not need to be recompiled when running on different platforms. The Java language masks information related to a specific platform using a Java virtual machine, so that a Java language compiler can be executed on a variety of platforms without modification by only generating object codes (bytecodes) to be executed on the Java virtual machine.
I/O Input/Output (Input/Output) is divided into two parts, I/O devices and I/O interfaces. On a POSIX (POSIX) compatible system, such as a Linux system, I/O operations can be performed in various ways, such as DI/O (Direct I/O), AI/O (Asynchronous I/O), Memory-Mapped I/O (Memory Mapped I/O), and the like, different I/O ways have different implementation manners and performances, and different I/O ways can be selected according to situations in different applications.
Hook technology, also called Hook function, before the system does not call the function, the Hook program captures the message first, the Hook function gets control right first, at this time, the Hook function can process (change) the execution behavior of the function, and can also end the transfer of the message forcibly. In short, the system program is pulled out to become the execution code segment of the system program, but the positive execution of the code segment is not influenced.
The method is characterized in that a plurality of probes (also called as detectors) are inserted into a program on the basis of ensuring the original logic integrity of the tested program, essentially, code segments for information acquisition are used, and can be assignment statements or function calls for acquiring coverage information, characteristic data of program operation are thrown out through the execution of the probes, and through the analysis of the data, control flow and data flow information of the program can be obtained, so that dynamic information such as logic coverage and the like can be obtained, and the test purpose is realized.
Jenkins is an open-source software project, is a continuous integration tool developed based on Java, is used for monitoring continuous and repeated work, and aims to provide an open and easy-to-use software platform to enable continuous integration of software to be possible. Jenkins functions include: persistent software version release/test projects, monitoring work performed by external calls.
With the development of information technology, the operation fluency and reliability of an application program or a system become more and more important research subjects, wherein the processing operation of a file is a main content, the file processing mainly relates to IO operation, the reasonable configuration of the IO operation greatly helps the use of software and the support of hardware, and currently, monitoring codes are mainly inserted into the system side of the application program for I/O optimization, but the mode can reduce the operation efficiency of the application program and cannot reflect the real operation condition of the application program.
As shown in fig. 1, an embodiment of the present specification provides an implementation environment schematic diagram of an IO performance detection method, where a detection target object may be an application program (APP) on an intelligent terminal 10, in an APP running process, a performance parameter for executing an IO operation in the APP operation is obtained through a preset probe function, and the performance parameter is sent to a monitoring platform 20, the monitoring platform or the intelligent terminal may process the performance parameter according to different detection strategies, and meanwhile, the monitoring platform may display the performance parameter, and generate a corresponding detection report according to different processing results.
The intelligent terminal 10 may be a vehicle control device, a smart phone, a desktop computer, a tablet computer, a notebook computer, a digital assistant, an intelligent wearable device, or other entity devices capable of applying an application program; wherein, wearable equipment of intelligence can include intelligent bracelet, intelligent wrist-watch, intelligent glasses, intelligent helmet etc.. Of course, the intelligent terminal is not limited to the electronic device with certain entity, and may also be software running in the electronic device, for example, the intelligent terminal may be a web page or an application provided to a user by a service provider.
The intelligent terminal 10 may include a display screen, a storage device and a processor connected by a data bus. The display screen is used for displaying an operation interface or interacting with a user and the like, and the display screen can be a touch screen of a vehicle machine, a mobile phone or a tablet computer and the like. The storage device is used for storing program codes, data materials and the like of the shooting device, and the storage device can be a memory of the intelligent terminal, and can also be a storage device such as a smart media card (smart media card), a secure digital card (secure digital card), a flash memory card (flash card) and the like. The processor may be a single core or multi-core processor.
The monitoring platform 20 may include a display screen, a storage device, and a processor connected by a data bus. The display screen is used for displaying an operation interface or interacting with a user and the like and is used for displaying received IO performance parameters, the storage device is used for storing the received IO performance parameters and a preset detection strategy, and the processor processes the IO performance parameters according to the preset detection strategy and generates a corresponding monitoring report according to a processing result.
Specifically, embodiments herein provide an IO performance detection method, which can reduce energy consumption for IO performance detection and improve reliability of IO performance monitoring, and fig. 2 is a schematic step diagram of the IO performance detection method provided in the embodiments herein, where the present specification provides method operation steps as described in the embodiments or flowcharts, but may include more or fewer operation steps based on conventional or non-creative labor. The order of steps recited in the embodiments is merely one manner of performing the steps in a multitude of orders and does not represent the only order of execution. When an actual system or apparatus product executes, it can execute sequentially or in parallel according to the method shown in the embodiment or the figures. Specifically, as shown in fig. 2, the method may include:
s101: when IO operation is detected, determining a target calling function corresponding to the IO operation;
s102: determining a probe function corresponding to the target calling function;
s103: obtaining IO performance parameters of the target calling function during operation through the probe function;
s104: and performing performance detection processing on the IO performance parameters according to a preset detection strategy.
In the embodiment of the specification, the call function in the IO operation is monitored through the probe function, so that the IO performance parameters can be quickly obtained, meanwhile, the performance influence on the detection target can be reduced, the reliability of the IO performance detection is improved, meanwhile, different preset detection strategies are combined, the simultaneous monitoring of various monitoring indexes can be realized, and the performance condition in the IO operation is comprehensively reflected.
It should be noted that in this embodiment of the present specification, an IO operation may be an operation of a disk file, such as a read-write operation, and in some other embodiments, the IO operation may also be a processing operation of other storage medium files, and different IO operation configuration files may be configured when different application programs or systems run, so that optimization of different application programs or system running programs may also be implemented by the method, and performance of responding to the IO operation is improved.
The target call function may be a specific execution function when a specific IO operation is performed, for example, operations such as opening, reading, writing, and closing a file in a disk, and the related functions may include an open (open) function, a read (read) function, a write (write) function, and a close (close) function, so that a corresponding IO performance parameter may be obtained as long as a runtime process on the file is obtained for each function.
Specifically, the open function is configured to obtain a file name, a file descriptor fd (file descriptor), an initial size of the file, stack information, and thread information when the file is opened, where the stack information refers to memory variable information in Android software, and includes heap information, stack information, a local variable, a global variable, and the like, and the thread information includes a main thread, an IO thread, a user-defined thread, and the like;
the reading function is used for acquiring the file type, the file content, the file reading mode, the file reading times, the total size of the read file, the Buffer size used in the file reading and the total time consumption of the reading process when the file is read;
the writing function is used for acquiring the file type and the file content when the file is written, the file writing mode, the file writing times, the total size of the written file, the Buffer size used when the file is written and the total time consumption of the writing process;
the close function is used for acquiring total time consumption for opening the file (time difference between file closing time and file opening time) and maximum continuous reading and writing time (in the total time consumption for opening the file, the maximum time consumption for reading and writing in the process of acquiring a read function and a write function).
The determining of the probe function corresponding to the target call function may be understood as: each of the target call functions corresponds to one of the probe functions, so that when the target call function is called, the processing information of the file during operation can be obtained through the probe function, as shown in fig. 3, so that step S101 may further include:
s201: acquiring a pre-configured relation corresponding table of a calling function and a probe function;
s202: and determining a probe function corresponding to the target calling function according to the relation corresponding table.
The relation correspondence table can be a correspondence between calling functions and probe functions, each calling function corresponds to one probe function under a general condition, and the probe functions can be quickly determined through the relation correspondence table on the premise of determining a target calling function, so that the positions of the probe functions are determined, and IO performance parameters during operation of the target calling function can be obtained through the probe functions when the target calling function is called.
In the embodiment of the present specification, the relationship correspondence table may be a probe function that configures all call functions involved in an IO operation process in advance, so that when a specific detection object (for example, an application program) is detected, only the corresponding probe function needs to be extracted, and thus, one-time configuration can be implemented, and multiple times of repeated use are performed, so that the use efficiency of the probe function is improved, and meanwhile, the detection efficiency of IO performance of different detection objects can also be improved.
In some other embodiments, corresponding call functions may also be configured according to different detection target objects, and as shown in fig. 4, the relationship correspondence table is obtained through the following steps:
s301: determining a target object to be detected;
s302: determining a calling function corresponding to the target object to be detected according to the target object to be detected;
s303: determining the position of the calling function in a corresponding calling function library according to the calling function;
s304: according to the position of the calling function, performing instrumentation processing on the calling function according to a preset instrumentation rule to obtain a probe function corresponding to the calling function;
s305: and generating the relation corresponding table according to the position relation of the probe function and the calling function.
The target object to be detected may be an application program (APP), or an operating system, or a specific business process (such as system restart, system update, etc.) in the system, and the target object to be detected configures a corresponding IO operation configuration file in advance, determines the rationality of the IO operation configuration file through a process of processing files in a system memory (such as a disk), and performs a corresponding optimization suggestion at the same time.
After the target object to be detected is determined, a corresponding call function may be determined according to the target object to be detected, and for most target objects, the call function may be all call functions of a disk operation, so that smoothness of the target object in operation may be ensured.
In the embodiment of the present specification, dynamic collection of corresponding call function feature data is realized through a instrumentation function (probe function), so that the IO performance of a disk can be obtained on the basis of not affecting the operation performance of each call function, thereby reducing performance consumption in the IO performance parameter obtaining process and ensuring the reliability of the IO performance parameters.
The preset stake inserting rule can be set according to actual conditions, such as native hook technology.
In actual operation, the calling function and the probe function are in a binding relationship, so that the relationship correspondence table only represents the correspondence between the calling function and the probe function, in actual operation, the setting of a real correspondence table is not needed, when the calling function is activated to run, the probe function corresponding to the calling function is also automatically activated to work, and the working information of the calling function is acquired, so that data acquisition is realized.
For example, as in the Android system, the calling function may be distributed in different function libraries, such as a libc.so library, which is a file format written based on the C + + language and used in the Android system, and is capable of storing various function methods, such as the functions of the above mentioned IO operations, when the specific operation is performed, the libc.so library called in the JVM has libjavacore.so, libopjdkjvm.so, libopjdkjkvm.so, and in addition to the above 3 libraries, the system may also use other so libraries by traversing the system, after determining the calling function, find the library address of the mmap area (i.e., the location of the calling function library) for each so library according to the so library name, and then peg-inserting the function, and inserting the probe function in the key place where the file is opened, the file is read, the file is written, and the file is closed.
In some embodiments, because the types of functions that need to be called during IO operations in different systems are also different, determining, according to the target object to be detected, a calling function corresponding to the target object to be detected may further include:
acquiring system version information of a target object to be detected;
and determining a calling function according to the target object to be detected and the system version information.
The system version information may be different versions in the system continuous update process, such as android6.0, android7.0, and the like, and call functions of IO operations in different versions may be different, for example, in versions above android7.0, the three call functions of open64, read _ chk, and write _ chk may also be instrumented, call functions in other systems may also be different, and details are not described in the embodiments of this specification.
In this embodiment of the present description, the performing instrumentation processing on the call function according to a preset instrumentation rule according to the position of the call function includes:
determining a calling code segment of the calling function according to the position of the calling function;
and inserting a probe code segment into a preset position of the calling code segment of the calling function to obtain a probe function, so that the probe function obtains IO performance parameters when the calling function runs.
It can be understood that the preset position can be the front position and the rear position of the calling function code segment, so that the integrity of the calling function code segment can be maintained, and the characteristic data of the calling function in the running process, such as file information and related information of file processing, can be obtained by inserting a function (or a probe function), so that IO performance parameters can be obtained, the acquisition of the IO performance information without extra consumption in real time is realized, and the reliability of parameter acquisition is improved.
In the embodiment of the present specification, the probe function is a Hook function, that is, through processing by Hook technology, non-intrusion and low-loss performance of the original code can be realized, so as to find problems in time.
To implement an automatic extraction and packing process for a call function, the method includes: after the target object to be detected is determined, the calling functions are determined according to the target object to be detected, the position of each calling function is determined by inquiring the function library, and automatic packaging processing is achieved so that the specific target object can be detected conveniently.
In actual work, the Git warehouse can be automatically constructed through a Jenkins automatic construction tool, the automatic construction aims to reduce labor cost of workers, and codes are automatically packaged through the tool to generate executable files. Git is a tool for code hosting, and can be understood as a place for storing code, and calling functions such as open, read, write, close and the like are arranged in the code. Jenkins searches a corresponding calling function on Git according to a specific detection object or a issued detection instruction, and then operates. Jenkins is an operating server program, and when a detection instruction is received, a calling function on a Git warehouse can be inquired according to the detection instruction, and the calling function is automatically packaged with codes to generate an executable APK android installation package. Therefore, the installation package can be prevented from being generated manually, the detection efficiency and cost are improved, and the condition of incomplete function coverage caused by manual packaging can be avoided.
When the instrumentation processing object is a call function in a libc.
In some other embodiments, the probe function is further configured to obtain CPU utilization and memory utilization information of the target object to be detected during operation. Certainly, the probe function needs to be inserted into a specific function, a detailed insertion process is not repeated in this specification, and by obtaining the CPU utilization rate and the memory utilization information of the target object to be detected during operation, comprehensive information of the target object to be detected during operation can be obtained, so that a more comprehensive reference can be provided for optimization of the target object to be detected.
In this embodiment of the present description, the processing the IO performance parameter according to a preset detection policy may further include:
and sending the IO performance parameters to a monitoring platform so that the monitoring platform displays the IO performance parameters, and analyzing the IO performance parameters according to the preset detection strategy.
The monitoring platform comprises a monitoring platform, an IO performance parameter display module, a monitoring module and a display module, wherein the monitoring platform is used for displaying the IO performance parameter, and the monitoring platform is used for monitoring the IO performance parameter.
Specifically, as shown in fig. 9, the preset detection policy may include a thread early warning policy, a Buffer size monitoring policy, a file monitoring policy, and a resource leakage monitoring policy. Each detection strategy can be realized by the detection result of at least one target calling function, wherein each detection strategy can comprise the following implementation modes:
as shown in fig. 5, when the preset detection policy is a thread early warning policy, the performing performance detection processing on the IO performance parameter according to the preset detection policy includes:
s401: acquiring the thread information during the IO operation;
s402: judging whether the IO operation runs a main thread or not according to the thread information;
s403: and if the IO operation runs in the main thread, generating early warning information.
In actual work, thread information during IO operation can be acquired through an open function, general I/O operation cannot be put into a main thread, if IO operation is in the main thread, in some cases, although the data size is Not large, jamming occurs, and even ANR (Application Not Responding) occurs, so that monitoring of I/O of the main thread can ensure fluency in the entire IO operation.
When IO operation uses a main thread, the monitoring platform generates early warning information, and an optimization scheme can be provided, for example, reading and writing of the IO operation can be realized through a sub-thread.
Further, as shown in fig. 6, when the preset detection policy is a Buffer size monitoring policy, the performing, according to the preset detection policy, performance detection processing on the IO performance parameter includes:
s501: acquiring the total size of a read or write file, and judging whether the total size of the file exceeds a file size threshold value;
s502: when the total size of the file exceeds the file size threshold, acquiring the number of times of reading or writing the file;
s503: calculating the size of a Buffer used when the file is read or written according to the total size of the read or write file and the number of times of reading or writing;
s504: judging whether the reading or writing times of the file exceed a time threshold value and/or whether the size of the Buffer is smaller than a Buffer size threshold value;
s505: and generating early warning information when the reading or writing times of the file exceed a time threshold value and/or the size of the Buffer is smaller than a Buffer size threshold value.
In actual work, a Buffer size monitoring policy can be comprehensively considered and executed through detection results of a plurality of functions, wherein the Buffer size is data configured in advance by a developer when the app is developed. If the Buffer set by the developer is too small, there is a problem, for example, when the Buffer is too small, the memory copy times are increased when a large file is read and written, which may increase the time consumption greatly. The file size threshold may be set according to an actual situation, for example, may be 500K, 1024K, or the like; the number threshold may also be set according to actual conditions, for example, the number threshold may be 10, and is not limited in this specification.
The Buffer size can be obtained by calculating the total size of the read or write file and the read or write times, and specifically, the Buffer size can be obtained by dividing the total size of the file by the read or write times. Therefore, when the situation that the time consumption is too long due to unreasonable Buffer size configured in advance or too large reading and writing times of a large file occurs, early warning is also needed to remind a user or a developer to perform optimization.
When the read-write times are too many due to the fact that the Buffer is too small, the monitoring platform can also provide an optimization scheme, such as increasing the size of the Buffer or multiplexing the Buffer.
In some other embodiments, the same file is repeatedly read in a short time, which increases the time consumption during IO operation and reduces the utilization efficiency of the file, and therefore, a secondary cache can be used to avoid the problem of repeated reading, for example, a disk is used as a primary cache, a memory is used as a secondary cache, and the file is temporarily stored in the memory after being read from the disk, so that the file is directly read from the memory when being read next time, and the file does not need to be read from the disk any more, and the IO operation is not generated.
In a further embodiment, except for the problem that the Buffer size and the number of times of reading and writing are too large, which may result in too long file processing time, it may also be a problem of a file reading manner, so as shown in fig. 6, the obtaining of the total size of the read or write file and the determining whether the total size of the file exceeds a file size threshold further include:
s506: when the total size of the file exceeds the file size threshold, acquiring a file reading or writing mode;
s507: and when the file reading or writing mode is a first mode, generating early warning information, wherein the first mode is an output stream mode according to an object.
It can be understood that when the APP is configured to read and write a large file in a write-by-write manner (e.g., Object Output Stream), the read and write time consumption of the file may increase, which may affect the operational fluency of the APP and affect the experience of the user, and at this time, an early warning is required, and further, the monitoring platform may prompt the developer to use Buffer Input Stream (write in Byte Array, write in batch) or Byte Array Output Stream (write in Buffer, write in batch) to reduce the time consumption, for example, a file of 60KB may reduce the time consumption by two hundred times.
Further, as shown in fig. 7, when the preset detection policy is a file monitoring policy, the performing, according to the preset detection policy, performance detection processing on the IO performance parameter includes:
s601: acquiring file names of a plurality of opened files, and judging whether files with the same file name exist or not;
s602: when at least two files with the same file name exist, acquiring file contents of the at least two files;
s603: when the file contents of the at least two files are the same, reading the file contents of the at least two files within a first preset time through the reading function;
s604: and judging whether the file contents of the at least two files are updated or not, and if not, generating early warning information.
In actual work, whether the same file name exists can be judged through an open function, and whether the contents of a plurality of files with the same name read through a read function are the same or not can be judged. In order to avoid the false alarm condition caused by the temporary storage of the same named civilization, a repeated check process in a first preset time period is further set, and after repeated check, if the content in the files with the same name is the same, early warning can be performed to remind a user of processing the files with the same name, wherein the first preset time can be set according to the actual condition.
Further, as shown in fig. 8, when the preset detection policy is a resource leakage monitoring policy, the performing, according to the preset detection policy, performance detection processing on the IO performance parameter includes:
s701: determining a file opened by the opening function;
s702: traversing the files opened by the opening function within a second preset time period, and judging whether the files which are not closed by the closing function exist or not;
s703: and when the file which is not closed by the closing function exists, generating early warning information.
In actual work, a complete and reasonable use process Of a file should be a process including an open function and a close function, after a file opened in an IO operation is not closed, the file resource occupies system resources and may cause resource leakage, a large number Of file handles which are not closed may occupy a large amount Of Memory, and even send an Out Of Memory (OOM) signal, for example, an app opens a picture, but there is no close function code in the code, although the interface cannot be seen, the Memory is occupied, if a new picture is continuously opened, it is found that the mobile phone Memory occupies more and more, and the Memory is more and more cards, and these wasted memories are called resource leakage. Therefore, in this specification, by judging whether a file opened by an open function is closed by a close function, an IO operation configuration file to be optimized therein can be determined in time, thereby improving the memory use efficiency.
In the IO performance detection method according to the embodiment of the present specification, the probe function is used for monitoring the call function during IO operation, so that IO performance parameters can be quickly obtained, meanwhile, the performance influence on a detection target can be reduced, the reliability of IO performance detection is improved, meanwhile, different preset detection strategies are combined, simultaneous monitoring of various monitoring indexes can be realized, and the performance condition during IO operation can be comprehensively reflected.
In an embodiment of this specification, as shown in fig. 10, this specification further provides an IO performance detection method, where the method is implemented by configuring the following devices: the system comprises an online monitoring platform, a Jenkins server, a Git server, an intelligent terminal (mobile terminal) and a server; the method comprises the steps that a target object to be detected, such as an application program, runs on the intelligent terminal, a user sends a monitoring command and configures a corresponding detection strategy on an online monitoring platform, a Jenkins server obtains a target calling function on a Git server after receiving a monitoring command, automatic packing is conducted, pile insertion processing is conducted through a Native Hook technology, a corresponding apk file is obtained and loaded on the intelligent terminal, in the running process of the target object to be detected, the program obtained by apk loading obtains IO performance parameters obtained through detection in real time and uploads the IO performance parameters to the server, the server is used for analyzing and storing the IO performance parameters, and corresponding data reports are generated according to analysis results and displayed on the online monitoring platform. The method has the advantages that by using a Native Hook technology, the performance influence of the App to be detected can be reduced to the maximum extent, and the service of the App to be detected is not influenced; the seed monitoring indexes (the size of the main thread I/O, Buffer, the repeated reading times and the resource leakage condition) can comprehensively reflect the operation condition of I/O; meanwhile, the I/O monitoring condition is reported in real time, and the platform intelligently analyzes the I/O use condition.
Based on the same inventive concept, as shown in fig. 11, an embodiment of this specification further provides an IO performance detection apparatus, where the apparatus includes:
a target call function determining module 100, configured to determine, when an IO operation is detected, a target call function corresponding to the IO operation;
a probe function determining module 200, configured to determine a probe function corresponding to the target call function;
an IO performance parameter obtaining module 300, configured to obtain, through the probe function, an IO performance parameter when the target call function runs;
and the performance detection module 400 is configured to perform performance detection processing on the IO performance parameters according to a preset detection policy.
The beneficial effects obtained by the device provided by the embodiment of the present specification and the method provided by the foregoing are consistent, and are not described herein again.
As shown in fig. 12, for a computer device provided for embodiments herein, the computer device 1202 may include one or more processors 1204, such as one or more Central Processing Units (CPUs), each of which may implement one or more hardware threads. Computer device 1202 may also include any memory 1206 for storing any kind of information, such as code, settings, data, etc. For example, and without limitation, memory 1206 may include any one or more of the following in combination: any type of RAM, any type of ROM, flash memory devices, hard disks, optical disks, etc. More generally, any memory may use any technology to store information. Further, any memory may provide volatile or non-volatile retention of information. Further, any memory may represent fixed or removable components of computer device 1202. In one case, when the processor 1204 executes associated instructions stored in any memory or combination of memories, the computer device 1202 may perform any of the operations of the associated instructions. The computer device 1202 also includes one or more drive mechanisms 1208 for interacting with any memory, such as a hard disk drive mechanism, an optical disk drive mechanism, and so forth.
The communication link 1222 may be implemented in any manner, such as through a local area network, a wide area network (e.g., the Internet), a point-to-point connection, etc., or any combination thereof. The communication link 1222 may include any combination of hardwired links, wireless links, routers, gateway functions, name servers, etc., governed by any protocol or combination of protocols.
Corresponding to the methods in fig. 2-8, the embodiments herein also provide a computer-readable storage medium having stored thereon a computer program, which, when executed by a processor, performs the steps of the above-described method.
Embodiments herein also provide computer readable instructions, wherein when executed by a processor, a program thereof causes the processor to perform the method as shown in fig. 2-8.
It should be understood that, in various embodiments herein, the sequence numbers of the above-mentioned processes do not mean the execution sequence, and the execution sequence of each process should be determined by its function and inherent logic, and should not constitute any limitation to the implementation process of the embodiments herein.
It should also be understood that, in the embodiments herein, the term "and/or" is only one kind of association relation describing an associated object, meaning that three kinds of relations may exist. For example, a and/or B, may represent: a exists alone, A and B exist simultaneously, and B exists alone. In addition, the character "/" herein generally indicates that the former and latter related objects are in an "or" relationship.
Those of ordinary skill in the art will appreciate that the elements and algorithm steps of the examples described in connection with the embodiments disclosed herein may be embodied in electronic hardware, computer software, or combinations of both, and that the components and steps of the examples have been described in a functional general in the foregoing description for the purpose of illustrating clearly the interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present disclosure.
It is clear to those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described systems, apparatuses and units may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.
In the several embodiments provided herein, it should be understood that the disclosed system, apparatus, and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may also be an electric, mechanical or other form of connection.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purposes of the embodiments herein.
In addition, functional units in the embodiments herein may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.
The integrated unit, if implemented in the form of a software functional unit and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solutions of the present invention may be implemented in a form of a software product, which is stored in a storage medium and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the methods described in the embodiments of the present invention. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and other various media capable of storing program codes.
The principles and embodiments of this document are explained herein using specific examples, which are presented only to aid in understanding the methods and their core concepts; meanwhile, for the general technical personnel in the field, according to the idea of this document, there may be changes in the concrete implementation and the application scope, in summary, this description should not be understood as the limitation of this document.
Claims (18)
1. An input/output (IO) performance detection method, the method comprising:
when IO operation is detected, determining a target calling function corresponding to the IO operation;
determining a probe function corresponding to the target calling function;
obtaining IO performance parameters of the target calling function during operation through the probe function;
and performing performance detection processing on the IO performance parameters according to a preset detection strategy.
2. The method of claim 1, wherein the determining the probe function corresponding to the target calling function comprises:
acquiring a pre-configured relation corresponding table of a calling function and a probe function;
and determining a probe function corresponding to the target calling function according to the relation corresponding table.
3. The method according to claim 2, wherein the relationship correspondence table is obtained by:
determining a target object to be detected;
determining a calling function corresponding to the target object to be detected according to the target object to be detected;
determining the position of the calling function in a corresponding calling function library according to the calling function;
according to the position of the calling function, performing instrumentation processing on the calling function according to a preset instrumentation rule to obtain a probe function corresponding to the calling function;
and generating the relation corresponding table according to the position relation of the probe function and the calling function.
4. The method according to claim 3, wherein the determining, according to the target object to be detected, the call function corresponding to the target object to be detected comprises:
acquiring system version information of a target object to be detected;
and determining a calling function according to the target object to be detected and the system version information.
5. The method according to claim 3, wherein the performing instrumentation processing on the calling function according to the position of the calling function and a preset instrumentation rule comprises:
determining a calling code segment of the calling function according to the position of the calling function;
and inserting a probe code segment into a preset position of the calling code segment of the calling function to obtain a probe function, so that the probe function obtains IO performance parameters when the calling function runs.
6. The method of claim 1, wherein the probe function is a hook function.
7. The method of claim 1, wherein the target call function comprises at least one of: an open function, a read function, a write function, and a close function;
the opening function is used for acquiring a file name, a file descriptor, an initial size of a file, stack information and thread information when the file is opened;
the reading function is used for acquiring the file type, the file content, the file reading mode, the file reading times, the total size of the read file, the Buffer size used in the file reading and the total time consumption of the reading process when the file is read;
the writing function is used for acquiring the file type and the file content when the file is written, the file writing mode, the file writing times, the total size of the written file, the Buffer size used when the file is written and the total time consumption of the writing process;
the closing function is used for acquiring the total time consumption of file opening and the maximum continuous reading and writing time.
8. The method according to claim 2, wherein the probe function is further used for acquiring CPU usage and memory usage information when the target object to be detected runs.
9. The method according to claim 1, wherein the processing the IO performance parameters according to a preset detection policy further includes:
and sending the IO performance parameters to a monitoring platform so that the monitoring platform displays the IO performance parameters, and analyzing the IO performance parameters according to the preset detection strategy.
10. The method of claim 7, wherein the preset detection strategies include a thread pre-warning strategy, a Buffer size monitoring strategy, a file monitoring strategy, and a resource leakage monitoring strategy.
11. The method according to claim 10, wherein when the preset detection policy is a thread early warning policy, performing performance detection processing on the IO performance parameter according to the preset detection policy includes:
acquiring the thread information during the IO operation;
judging whether the IO operation runs a main thread or not according to the thread information;
and if the IO operation runs in the main thread, generating early warning information.
12. The method according to claim 9, wherein when the preset detection policy is a Buffer size monitoring policy, the performing performance detection processing on the IO performance parameter according to the preset detection policy includes:
acquiring the total size of a read or write file, and judging whether the total size of the file exceeds a file size threshold value;
when the total size of the file exceeds the file size threshold, acquiring the number of times of reading or writing the file;
calculating the size of a Buffer used when the file is read or written according to the total size of the read or write file and the number of times of reading or writing;
judging whether the reading or writing times of the file exceed a time threshold value and/or whether the size of the Buffer is smaller than a Buffer size threshold value;
and generating early warning information when the reading or writing times of the file exceed a time threshold value and/or the size of the Buffer is smaller than a Buffer size threshold value.
13. The method of claim 12, wherein obtaining the total size of the read or write file and determining whether the total size of the file exceeds a file size threshold further comprises:
when the total size of the file exceeds the file size threshold, acquiring a file reading or writing mode;
and when the file reading or writing mode is a first mode, generating early warning information, wherein the first mode is an output stream mode according to an object.
14. The method according to claim 10, wherein when the preset detection policy is a file monitoring policy, performing performance detection processing on the IO performance parameter according to the preset detection policy includes:
acquiring file names of a plurality of opened files, and judging whether files with the same file name exist or not;
when at least two files with the same file name exist, acquiring file contents of the at least two files;
when the file contents of the at least two files are the same, reading the file contents of the at least two files within a first preset time through the reading function;
and judging whether the file contents of the at least two files are updated or not, and if not, generating early warning information.
15. The method according to claim 10, wherein when the preset detection policy is a resource leakage monitoring policy, performing performance detection processing on the IO performance parameter according to the preset detection policy includes:
determining a file opened by the opening function;
traversing the files opened by the opening function within a second preset time period, and judging whether the files which are not closed by the closing function exist or not;
and when the file which is not closed by the closing function exists, generating early warning information.
16. An IO performance detection apparatus, the apparatus comprising:
the target calling function determining module is used for determining a target calling function corresponding to the IO operation when the IO operation is detected;
the probe function determining module is used for determining a probe function corresponding to the target calling function;
an IO performance parameter obtaining module, configured to obtain, through the probe function, an IO performance parameter when the target call function operates;
and the performance detection module is used for carrying out performance detection processing on the IO performance parameters according to a preset detection strategy.
17. A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the method steps of any of claims 1 to 15 when executing the computer program.
18. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program which, when being executed by a processor, carries out the method steps of any one of claims 1 to 15.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110338422.XA CN113076233B (en) | 2021-03-30 | 2021-03-30 | IO performance detection method, device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110338422.XA CN113076233B (en) | 2021-03-30 | 2021-03-30 | IO performance detection method, device, equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113076233A true CN113076233A (en) | 2021-07-06 |
| CN113076233B CN113076233B (en) | 2024-02-27 |
Family
ID=76611473
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110338422.XA Active CN113076233B (en) | 2021-03-30 | 2021-03-30 | IO performance detection method, device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113076233B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113268436A (en) * | 2021-07-21 | 2021-08-17 | 航天中认软件测评科技（北京）有限责任公司 | Multi-granularity computer simulation operation information acquisition method based on hook points |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109542341A (en) * | 2018-11-06 | 2019-03-29 | 网宿科技股份有限公司 | A kind of read-write IO monitoring method, device, terminal and computer readable storage medium |
| CN110795358A (en) * | 2020-01-06 | 2020-02-14 | 同盾控股有限公司 | Code instrumentation detection method, apparatus, device and medium |
| US20200192789A1 (en) * | 2018-12-18 | 2020-06-18 | Sap Se | Graph based code performance analysis |
| CN111756575A (en) * | 2020-06-19 | 2020-10-09 | 星辰天合（北京）数据科技有限公司 | Performance analysis method and device of storage server and electronic equipment |
| CN111752793A (en) * | 2020-05-27 | 2020-10-09 | 中国平安财产保险股份有限公司 | System abnormity monitoring method and device, computer equipment and storage medium |
-
2021
- 2021-03-30 CN CN202110338422.XA patent/CN113076233B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109542341A (en) * | 2018-11-06 | 2019-03-29 | 网宿科技股份有限公司 | A kind of read-write IO monitoring method, device, terminal and computer readable storage medium |
| US20200192789A1 (en) * | 2018-12-18 | 2020-06-18 | Sap Se | Graph based code performance analysis |
| CN110795358A (en) * | 2020-01-06 | 2020-02-14 | 同盾控股有限公司 | Code instrumentation detection method, apparatus, device and medium |
| CN111752793A (en) * | 2020-05-27 | 2020-10-09 | 中国平安财产保险股份有限公司 | System abnormity monitoring method and device, computer equipment and storage medium |
| CN111756575A (en) * | 2020-06-19 | 2020-10-09 | 星辰天合（北京）数据科技有限公司 | Performance analysis method and device of storage server and electronic equipment |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113268436A (en) * | 2021-07-21 | 2021-08-17 | 航天中认软件测评科技（北京）有限责任公司 | Multi-granularity computer simulation operation information acquisition method based on hook points |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113076233B (en) | 2024-02-27 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108874624B (en) | Server, method for monitoring Java process and storage medium | |
| US9262283B2 (en) | Method for reading kernel log upon kernel panic in operating system | |
| US10599558B1 (en) | System and method for identifying inputs to trigger software bugs | |
| CN110457211B (en) | Script performance test method, device and equipment and computer storage medium | |
| US20150052400A1 (en) | Breakpoint Setting Through a Debugger User Interface | |
| JP2009516239A (en) | General purpose multi-instance method and GUI detection system for tracking and monitoring computer applications | |
| CA2226224A1 (en) | Fast traps for computer software instrumentation | |
| KR20130031860A (en) | System testing method | |
| CN114222975A (en) | Data preservation using memory aperture flush sequence | |
| US8458670B2 (en) | Automatically adding bytecode to a software application to determine network communication information | |
| CN106844182B (en) | Method, system and mobile terminal for recording user behavior | |
| US10311233B2 (en) | Generic unpacking of program binaries | |
| US20200218803A1 (en) | Call stack acquisition device, call stack acquisition method, and call stack acquisition program | |
| KR20130123582A (en) | Method for monitoring log and server thereof, and recording medium | |
| CN111258752A (en) | Resource monitoring method and device, electronic equipment and storage medium | |
| CN112214388A (en) | Memory monitoring method, device, equipment and computer readable storage medium | |
| EP3036636A1 (en) | Snapshotting executing code with a modifiable snapshot definition | |
| Ki et al. | Reptor: Enabling api virtualization on android for platform openness | |
| US10275595B2 (en) | System and method for characterizing malware | |
| CN110554998A (en) | hook method, device, terminal and storage medium for replacing function internal instruction | |
| CN113076233B (en) | IO performance detection method, device, equipment and storage medium | |
| CN109359092B (en) | File management method, desktop display method, device, terminal and medium | |
| CN113127050A (en) | Application resource packaging process monitoring method, device, equipment and medium | |
| CN110764962A (en) | Log processing method and device | |
| EP3692456B1 (en) | Binary image stack cookie protection |
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 |