Method, device and equipment for acquiring graphics processor failure data and storage medium

Abstract

The disclosure discloses a method and device for acquiring fault data of a graphics processor, an equipment and a storage medium, and relates to the technical field of computers. An output value of a preset monitoring function at a current time is determined, wherein the preset monitoring function is used for monitoring the state of a time node in a GPU driver. In the case that the output value is a preset value, data in a dump node related to the current time in the GPU driver is acquired. According to the data in the dump node, fault data corresponding to the GPU at the current time is determined. Thus, by using the file system node in the original GPU driver and the polling function waiting method, the fault data of the GPU can be captured in real time at the user layer, so that the real-time monitoring of the GPU fault can be ensured at a low cost.

Description

Technical Field

[0001] This disclosure relates to the field of computer technology, and in particular to a method, apparatus, device, and storage medium for acquiring graphics processor fault data. Background Technology

[0002] Currently on Qualcomm platforms, when monitoring for faults in the Graphics Processing Unit (GPU), it is usually necessary to place a manually written configuration file in a designated directory. Then, when a GPU malfunctions, the fault data of the current GPU can be captured through the configuration file.

[0003] However, in current mass production projects, numerous permission issues make it difficult to place configuration files in designated directories. Consequently, Qualcomm platforms lack the necessary configuration files and cannot promptly obtain GPU fault data. Therefore, effectively and timely acquiring current GPU fault data is a pressing issue that requires attention. Summary of the Invention

[0004] This disclosure provides a method, apparatus, device, and storage medium for acquiring graphics processor fault data.

[0005] According to a first aspect of this disclosure, a method for acquiring graphics processor fault data is provided, comprising:

[0006] Determine the output value of a preset monitoring function at the current moment, wherein the preset monitoring function is used to monitor the state of time nodes in the GPU driver;

[0007] If the output value is a preset value, the data in the transfer node related to the current time in the GPU driver is obtained;

[0008] Based on the data in the transfer node, determine the fault data corresponding to the GPU at the current moment.

[0009] According to a second aspect of this disclosure, an apparatus for acquiring graphics processor fault data is provided, comprising:

[0010] The first determining module is used to determine the output value of a preset monitoring function at the current moment, wherein the preset monitoring function is used to monitor the state of time nodes in the GPU driver.

[0011] The acquisition module is used to acquire data from the transfer node in the GPU driver that is related to the current time when the output value is a preset value.

[0012] The second determining module is used to determine the fault data corresponding to the GPU at the current moment based on the data in the transfer node.

[0013] A third aspect of this disclosure provides a computer device, including: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the program, implements the method as described in the first aspect of this application.

[0014] A fourth aspect of this disclosure provides a non-transitory computer-readable storage medium storing a computer program that, when executed by a processor, implements the method as described in the first aspect of this application.

[0015] A fifth aspect of this disclosure provides a computer program product that, when executed by an instruction processor, performs the method proposed in a first aspect of this disclosure.

[0016] In this embodiment, the output value of a preset monitoring function at the current moment is first determined. This preset monitoring function monitors the state of time nodes in the GPU driver. Then, given the preset output value, data from the transfer node in the GPU driver related to the current moment is obtained. Finally, based on the data in the transfer node, the fault data corresponding to the GPU at the current moment is determined. Thus, by utilizing the file system nodes in the existing GPU driver and employing the poll function to wait, real-time capture of GPU fault data at the user level is achieved, ensuring real-time monitoring of GPU faults with relatively low overhead.

[0017] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0018] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein:

[0019] Figure 1 A flowchart illustrating a method for acquiring graphics processor fault data provided in this embodiment of the present disclosure;

[0020] Figure 2 A flowchart illustrating another method for acquiring graphics processor fault data provided in this embodiment of the present disclosure;

[0021] Figure 3 A structural block diagram of a graphics processor fault data acquisition device provided in this embodiment of the present disclosure;

[0022] Figure 4 This is a block diagram of an electronic device used to implement the method for acquiring graphics processor fault data according to embodiments of the present disclosure. Detailed Implementation

[0023] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0024] This disclosure provides a method for acquiring graphics processor fault data. This method can be executed by a graphics processor fault data acquisition device provided by this disclosure, or by a server provided by this disclosure, without limitation.

[0025] The following describes the implementation of a graphics processor fault data acquisition method provided in this disclosure using a graphics processor fault data acquisition device, and is not intended to limit this disclosure.

[0026] The following describes in detail, with reference to the accompanying drawings, the method, apparatus, computer equipment, and storage medium for acquiring graphics processor fault data provided in this disclosure.

[0027] Figure 1 This is a flowchart illustrating a method for acquiring graphics processor fault data according to an embodiment of this disclosure.

[0028] like Figure 1 As shown, the method for obtaining graphics processor fault data may include the following steps:

[0029] Step 101: Determine the output value of the preset monitoring function at the current moment, wherein the preset monitoring function is used to monitor the state of time nodes in the GPU driver.

[0030] It should be noted that GPU drivers typically pre-define time nodes and transfer nodes. The time node can be a timestamp. During GPU operation, if a failure occurs, the moment of the failure is written to this time node, meaning the state of the time node will change. Relevant data about the GPU failure is then stored in the transfer node. In this disclosure, the state of the time node can be monitored in real time using a pre-defined monitoring function to determine whether a GPU failure has occurred.

[0031] The preset monitoring function can be the `poll` function. By calling the `poll` function, the status of time nodes in the GPU driver can be read in real time, and then the corresponding value can be output based on the read node status. For example, if the `poll` function outputs 1 when it detects a change in the time parameter of a time node, and outputs 0 when it detects a change in the time parameter of a time node, then in this disclosure, the operating status of the GPU can be monitored based on the return value of this function, that is, the output value.

[0032] In this disclosure, the GPU failure problem can be referred to as GPU hang, where the corresponding failure symptoms can be machine screen freezing, machine restart, or application freezing, without being limited to any specific issue.

[0033] Step 102: If the output value is a preset value, obtain the data in the transfer node related to the current moment in the GPU driver.

[0034] The preset value can be any pre-defined value that the poll function can output when it detects the state of a time node, such as 1 or 0, etc. This disclosure does not limit it.

[0035] It should be noted that dump nodes, such as the dump node, can be pre-configured in the GPU driver. These dump nodes can be used to store, copy, and restore GPU-related data. In this disclosure, data related to GPU problems can be saved using dump nodes. To improve usability and manageability, after retrieving data from a dump node in the GPU driver that is relevant to the current moment, the data in that dump node can be deleted promptly.

[0036] It should be noted that if the current output value is a preset value, it indicates that the GPU has malfunctioned. In this disclosure, when the output value is a preset value, the data related to the GPU problem can be saved and stored in the transfer node in the GPU driver. Understandably, the data of the transfer node related to the current moment can be saved as a file.

[0037] Optionally, if the output value is not a preset value, return the output value of the monitoring function at the current moment when the preset value is executed.

[0038] It should be noted that if the current output value is not the preset value, the output value of the preset monitoring function can continue to be monitored so that when its output value is the preset value, the associated data can be stored in real time, thereby realizing continuous monitoring of the status of time nodes in the GPU driver.

[0039] Step 103: Determine the fault data corresponding to the GPU at the current moment based on the data in the transfer node.

[0040] It should be noted that the GPU-related memory data and GPU-related register data corresponding to the current moment in the transfer node can be used as the fault data corresponding to the current moment. In this disclosure, this fault data can be stored for subsequent analysis of GPU faults.

[0041] In this embodiment, the output value of a preset monitoring function at the current moment is first determined. This preset monitoring function monitors the state of time nodes in the GPU driver. Then, given the preset output value, data from the transfer node in the GPU driver related to the current moment is obtained. Finally, based on the data in the transfer node, the fault data corresponding to the GPU at the current moment is determined. Thus, by utilizing the file system nodes in the existing GPU driver and employing the poll function to wait, real-time capture of GPU fault data at the user level is achieved, ensuring real-time monitoring of GPU faults with relatively low overhead.

[0042] Figure 2 This is a flowchart illustrating another method for acquiring graphics processor fault data according to an embodiment of this disclosure.

[0043] like Figure 2 As shown, the method for obtaining graphics processor fault data may include the following steps:

[0044] Step 201: Determine the output value of the preset monitoring function at the current moment, wherein the preset monitoring function is used to monitor the state of time nodes in the GPU driver.

[0045] It should be noted that the specific implementation of step 201 can refer to step 101 above, and will not be repeated here.

[0046] Step 202: If the output value is a preset value, start a preset thread to obtain data from the transfer node related to the current moment from the GPU driver.

[0047] Optionally, a pre-defined thread can be created in the pre-defined log service program.

[0048] The pre-defined log service program is used to save logs. After creating the log service program, a pre-defined thread can be created within it. This pre-defined thread can be a thread related to GPU snapshots, through which the poll function can be run to monitor the status of time nodes in the GPU driver.

[0049] Specifically, given a preset output value, the device can start a preset thread and retrieve data from the transfer node related to the current moment from the GPU driver. The data in the transfer node can include important information such as relevant memory data used by the GPU and GPU-related registers, which are not limited here.

[0050] Optionally, after acquiring the data from the transfer node relevant to the current moment, the device can control a preset thread to enter a sleep state, thereby saving system resources and avoiding system consumption when there are no GPU problems.

[0051] Step 203: Determine the fault data corresponding to the GPU at the current moment based on the data in the transfer node.

[0052] It should be noted that the specific implementation of step 203 can refer to step 103 above, and will not be repeated here.

[0053] Step 204: Compress the fault data corresponding to the GPU at the current moment to generate a log file.

[0054] Optionally, when a GPU malfunctions, the fault data corresponding to the GPU at the moment of failure can be determined, and the fault data can be captured in a timely manner through snapshot files, and then compressed to generate log files.

[0055] Alternatively, the fault data corresponding to the GPU at the current moment can be compressed to generate a log file. The log file can be named according to the time the fault data was retrieved, thus ensuring that log files with the same name will not be overwritten if multiple log files exist.

[0056] Step 205: Store the log file and the current time in a preset log folder.

[0057] The preset log folder is used to save the uploaded log files. In this disclosure, the preset log folder can be a folder preset on the user's vehicle terminal.

[0058] It should be noted that by storing log files in association with the current time, log file name conflicts can be avoided.

[0059] Step 206: Upload the log files to the log server according to the preset cycle.

[0060] It should be noted that after generating the log files, the contents of the log storage folder can be uploaded to the log server at certain intervals, such as according to a preset period. The device can then use specified tools to filter, classify, and further manually analyze the logs. In this disclosure, the log server is primarily used to store the user's vehicle-mounted system's log information.

[0061] In this embodiment, the output value of a preset monitoring function at the current moment is first determined. This preset monitoring function monitors the state of time nodes in the GPU driver. Then, if the output value is the preset value, a preset thread is started to retrieve data from the transfer node related to the current moment in the GPU driver. Based on the data in the transfer node, the fault data corresponding to the GPU at the current moment is determined. This fault data is then compressed to generate a log file, which is stored in a preset log folder along with the current moment. Finally, the log file is uploaded to a log server at a preset period. Thus, by utilizing the file system nodes in the existing GPU driver and employing the poll function, fault data corresponding to the GPU at the time of failure can be promptly detected, retrieved, and stored. This facilitates timely restoration and recovery of GPU faults, resolving the fault and improving the user experience.

[0062] To implement the above embodiments, this disclosure also proposes a device for acquiring graphics processor fault data.

[0063] Figure 3 This is a schematic diagram of a device for acquiring graphics processor fault data provided in an embodiment of the present disclosure.

[0064] like Figure 3 As shown, the graphics processor fault data acquisition device 300 includes a first determination module 310, an acquisition module 320, and a second determination module 330:

[0065] The first determining module 310 is used to determine the output value of a preset monitoring function at the current moment, wherein the preset monitoring function is used to monitor the state of time nodes in the GPU driver.

[0066] The acquisition module 320 is used to acquire data in the transfer node related to the current time in the GPU driver when the output value is a preset value;

[0067] The second determining module 330 is used to determine the fault data corresponding to the GPU at the current moment based on the data in the transfer node.

[0068] Optionally, the acquisition module includes:

[0069] The acquisition unit is used to start a preset thread to acquire data from the GPU driver in the transfer node related to the current moment.

[0070] Optionally, the acquisition unit is further configured to:

[0071] The preset thread is created in the preset log service program.

[0072] Optionally, the acquisition unit is further configured to:

[0073] Control the preset thread to enter a sleep state.

[0074] Optionally, the first determining module is further configured to:

[0075] If the output value is not the preset value, return the output value of the monitoring function that determines the preset value at the current time.

[0076] Optionally, the second determining module is further configured to:

[0077] The fault data corresponding to the GPU at the current moment is compressed to generate a log file;

[0078] The log file and the current time are associated and stored in a preset log folder;

[0079] The log files are uploaded to the log server at a preset period.

[0080] In this embodiment, the output value of a preset monitoring function at the current moment is first determined. This preset monitoring function monitors the state of time nodes in the GPU driver. Then, given the preset output value, data from the transfer node in the GPU driver related to the current moment is obtained. Finally, based on the data in the transfer node, the fault data corresponding to the GPU at the current moment is determined. Thus, by utilizing the file system nodes in the existing GPU driver and employing the poll function to wait, real-time capture of GPU fault data at the user level is achieved, ensuring real-time monitoring of GPU faults with relatively low overhead.

[0081] According to embodiments of this disclosure, this disclosure also provides an electronic device, a readable storage medium, and a computer program product.

[0082] Figure 4A schematic block diagram of an example electronic device 400 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0083] like Figure 4 As shown, device 400 includes a computing unit 401, which can perform various appropriate actions and processes based on a computer program stored in read-only memory (ROM) 402 or a computer program loaded from storage unit 408 into random access memory (RAM) 403. RAM 403 may also store various programs and data required for the operation of device 400. The computing unit 401, ROM 402, and RAM 403 are interconnected via bus 404. Input / output (I / O) interface 405 is also connected to bus 404.

[0084] Multiple components in device 400 are connected to I / O interface 405, including: input unit 406, such as keyboard, mouse, etc.; output unit 407, such as various types of monitors, speakers, etc.; storage unit 408, such as disk, optical disk, etc.; and communication unit 409, such as network card, modem, wireless transceiver, etc. Communication unit 409 allows device 400 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0085] The computing unit 401 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 401 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 401 performs the various methods and processes described above, such as the method for acquiring graphics processor fault data. For example, in some embodiments, the method for acquiring graphics processor fault data may be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 408. In some embodiments, part or all of the computer program may be loaded and / or installed on device 400 via ROM 402 and / or communication unit 409. When the computer program is loaded into RAM 403 and executed by the computing unit 401, one or more steps of the method for acquiring graphics processor fault data described above may be performed. Alternatively, in other embodiments, the computing unit 401 may be configured to perform the method for acquiring graphics processor fault data by any other suitable means (e.g., by means of firmware).

[0086] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0087] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0088] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0089] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0090] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or middleware components (e.g., application servers), or frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), the Internet, and blockchain networks.

[0091] Computer systems can include clients and servers. Clients and servers are generally geographically separated and typically interact via communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. A server can be a cloud server, also known as a cloud computing server or cloud host, a hosting product within the cloud computing service ecosystem, addressing the shortcomings of traditional physical hosts and VPS (Virtual Private Server, or simply "VPS") services, such as high management difficulty and weak business scalability. Servers can also be servers for distributed systems or servers incorporating blockchain technology.

[0092] In this embodiment, the output value of a preset monitoring function at the current moment is first determined. This preset monitoring function monitors the state of time nodes in the GPU driver. Then, given the preset output value, data from the transfer node in the GPU driver related to the current moment is obtained. Finally, based on the data in the transfer node, the fault data corresponding to the GPU at the current moment is determined. Thus, by utilizing the file system nodes in the existing GPU driver and employing the poll function to wait, real-time capture of GPU fault data at the user level is achieved, ensuring real-time monitoring of GPU faults with relatively low overhead.

[0093] It should be understood that the various forms of processes shown above can be used to reorder, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0094] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A method for acquiring graphics processor fault data, characterized in that, include: Determine the output value of a preset monitoring function at the current moment, wherein the preset monitoring function is used to monitor the state of time nodes in the GPU driver, the GPU driver pre-sets a transfer node, and the preset monitoring function is the poll l function, wherein the output value is used to characterize whether the time parameters in the time node have changed; When the output value is a preset value, a preset thread is started to obtain data from the transfer node in the GPU driver that is related to the current time. The data in the transfer node includes the relevant memory data used by the GPU and the data of the GPU-related registers. Based on the data in the transfer node, determine the fault data corresponding to the GPU at the current moment.

2. The method according to claim 1, characterized in that, Before starting the preset thread to retrieve data from the transfer node related to the current moment from the GPU driver, the method further includes: The preset thread is created in the preset log service program.

3. The method as described in claim 1, characterized in that, After obtaining the data from the transfer node in the GPU driver related to the current time, the method further includes: Control the preset thread to enter a sleep state.

4. The method according to claim 1, characterized in that, After determining the output value of the preset monitoring function at the current moment, the method further includes: If the output value is not the preset value, return the output value of the monitoring function that determines the preset value at the current time.

5. The method according to any one of claims 1-4, characterized in that, After determining the fault data corresponding to the GPU at the current moment based on the data in the transfer node, the method further includes: The fault data corresponding to the GPU at the current moment is compressed to generate a log file; The log file and the current time are associated and stored in a preset log folder; The log files are uploaded to the log server at a preset period.

6. A device for acquiring graphics processor fault data, characterized in that, include: The first determining module is used to determine the output value of a preset monitoring function at the current moment. The preset monitoring function is used to monitor the state of time nodes in the GPU driver. The GPU driver pre-sets a transfer node. The preset monitoring function is the poll l function. The output value is used to characterize whether the time parameters in the time node have changed. The acquisition module is used to acquire data in the transfer node related to the current time in the GPU driver when the output value is a preset value. The data in the transfer node includes data of the relevant memory used by the GPU and data of the GPU-related registers. The second determining module is used to determine the fault data corresponding to the GPU at the current moment based on the data in the transfer node; The acquisition module includes: The acquisition unit is used to start a preset thread to acquire data from the GPU driver in the transfer node related to the current moment.

7. The apparatus according to claim 6, characterized in that, The acquisition unit is further configured to: The preset thread is created in the preset log service program.

8. The apparatus as claimed in claim 6, characterized in that, The acquisition unit is further configured to: Control the preset thread to enter a sleep state.

9. The apparatus according to claim 6, characterized in that, The first determining module is further configured to: If the output value is not the preset value, return the output value of the monitoring function that determines the preset value at the current time.

10. The apparatus according to any one of claims 6-9, characterized in that, The second determining module is further configured to: The fault data corresponding to the GPU at the current moment is compressed to generate a log file; The log file and the current time are associated and stored in a preset log folder; The log files are uploaded to the log server at a preset period.

11. An electronic device, comprising: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-5.

12. A non-transitory computer-readable storage medium storing computer instructions, wherein, The computer instructions are used to cause the computer to perform the method according to any one of claims 1-5.

13. A computer program product comprising a computer program that, when executed by a processor, implements the method according to any one of claims 1-5.

Images