Debugging method and device, server, medium and product
By deploying a simulated GPU module response module in a server without a GPU module, the debugging challenges in a GPU-free environment are solved, enabling efficient debugging and performance optimization while reducing hardware dependence.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- NINGCHANG INFORMATION TECH (HANGZHOU) CO LTD
- Filing Date
- 2026-01-05
- Publication Date
- 2026-05-19
AI Technical Summary
In server environments without GPU modules, debugging requests cannot be responded to via the actual GPU, making it difficult to debug the GPU module monitoring module.
Deploy a simulated GPU module response module in a server without a physical GPU module. This simulated GPU module response module receives interface request data and sends back response data, thereby enabling the debugging of the GPU module monitoring module.
It significantly reduces the cost of setting up the debugging environment and hardware dependence, improves debugging efficiency and reliability, and supports communication protocol verification and system performance optimization.
Smart Images
Figure CN122064547A_ABST
Abstract
Description
Technical Field
[0001] This disclosure relates to the field of computer technology, and more specifically, to a debugging method, apparatus, server, medium, and product. Background Technology
[0002] In the current era of rapid development in artificial intelligence technology, GPUs have become an indispensable computing power support for training large models. GPU modules are high-density integrated solutions built on top of single GPU cards, primarily addressing the performance and efficiency bottlenecks of single cards in ultra-large-scale computing scenarios. With the exponential growth in AI computing power demands, modularization will be an inevitable choice for high-performance computing. Furthermore, when using GPUs in servers to implement related functions, the GPU module monitoring module within the server is debugged based on the server's Baseboard Management Controller (BMC).
[0003] However, in server environments without GPU modules, debugging requests cannot be responded to via the actual GPU, making it difficult to debug the GPU module monitoring module. Summary of the Invention
[0004] The purpose of this disclosure is to provide a debugging method, apparatus, server, medium, and product.
[0005] To achieve the above objectives, in a first aspect, this disclosure provides a debugging method applied to a server without a GPU module, the server including a simulated GPU module response module for responding to requested data, the method comprising: The GPU module monitoring module in the server sends interface request data to the simulated GPU module response module. Receive response data from the simulated GPU module response module based on the interface request data; The GPU module monitoring module is debugged based on the response data. By deploying a simulated GPU module response module in a server without a physical GPU module, the response data corresponding to the interface request data can be accurately obtained. Based on the response data, the GPU module monitoring module can be debugged, which can effectively simulate the communication behavior of a real GPU module. This significantly reduces the cost of setting up the debugging environment and hardware dependence, and provides reliable support for communication protocol verification and system performance optimization.
[0006] Optionally, debugging the GPU module monitoring module based on the response data includes: Obtain the GPU response dataset, which includes multiple Redfish interfaces and preset response data corresponding to each Redfish interface; Based on the interface request data, determine the preset response data corresponding to the interface request data from the GPU response dataset; The GPU module monitoring module is debugged based on the response data and the preset response data. By flexibly acquiring communication configurations, parsing verification response data, and combining preset datasets for multi-dimensional comparison, it can accurately identify functional abnormalities and data deviations in GPU module monitoring modules. It also supports dynamic debugging and strategy optimization, effectively improving the stability, maintainability, and fault location efficiency of the monitoring system.
[0007] Optionally, the step of debugging the GPU module monitoring module based on the response data and the preset response data includes: The GPU module monitoring module is debugged based on the consistency between the response data and the preset response data. It facilitates quick identification of the root cause of the problem.
[0008] Optionally, the step of debugging the GPU module monitoring module based on the consistency between the response data and the preset response data includes: If the response data is the same as the preset response data, it is determined that the GPU module monitoring module is functioning normally. If the response data is different from the preset response data, the function of the GPU module monitoring module is determined to be abnormal. It can achieve closed-loop debugging of the reliability of the GPU module monitoring module itself, so as to ensure that the monitoring data of the GPU module monitoring module is accurate and reliable, and can operate stably under various working conditions.
[0009] Optionally, after receiving the response data from the simulated GPU module response module based on the interface request data, the method further includes: The response data is parsed to obtain the parsed response data; The step of debugging the GPU module monitoring module based on the response data includes: The GPU module monitoring module is debugged based on the parsed response data. The debugging process dynamically adjusts the monitoring strategy based on the analysis results to improve system stability and real-time performance.
[0010] Optionally, before sending interface request data to the simulated GPU module response module through the GPU module monitoring module in the server, the method further includes: Obtain the communication IP information and communication port information of the simulated GPU module response module; Obtaining the communication IP and port information of the simulated GPU module response module can be used for target address and port configuration when establishing a network connection, ensuring that data packets are accurately routed to the simulated module.
[0011] Secondly, this disclosure provides a debugging apparatus for use in a server without a GPU module, the server including a simulated GPU module response module for responding to requested data, the apparatus comprising: The data sending unit is configured to send interface request data to the simulated GPU module response module through the GPU module monitoring module in the server; The data receiving unit is configured to receive response data from the simulated GPU module response module based on the interface request data feedback. The module debugging unit is configured to debug the GPU module monitoring module based on the response data.
[0012] Thirdly, this disclosure provides a server, including: GPU module monitoring module; A simulated GPU module response module is used to respond to requested data; A memory on which computer programs are stored; A processor for executing the computer program in the memory to implement the steps of the method described in the first aspect.
[0013] Fourthly, this disclosure provides a computer-readable storage medium having a computer program stored thereon that, when executed by a processor, implements the steps of the method described in the first aspect.
[0014] Fifthly, this disclosure provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the method described in the first aspect.
[0015] The above technical solution, by deploying a simulated GPU module response module in a server without a physical GPU module, can accurately obtain the response data corresponding to the interface request data, and debug the GPU module monitoring module based on the response data. It can effectively simulate the communication behavior of a real GPU module, significantly reduce the cost of setting up the debugging environment and hardware dependence, and provide reliable support for communication protocol verification and system performance optimization.
[0016] Other features and advantages of this disclosure will be described in detail in the following detailed description section. Attached Figure Description
[0017] The accompanying drawings are provided to further illustrate the present disclosure and form part of the specification. They are used together with the following detailed description to explain the present disclosure, but do not constitute a limitation thereof. In the drawings: Figure 1 A schematic diagram of debugging based on the GPU module is shown.
[0018] Figure 2 This is a flowchart illustrating a debugging method according to an exemplary embodiment.
[0019] Figure 3 This is a flowchart illustrating a debugging method according to another exemplary embodiment.
[0020] Figure 4 A schematic diagram of the debugging of the GPU module monitoring module is shown when there is no GPU module.
[0021] Figure 5 This is a block diagram illustrating a debugging apparatus according to an exemplary embodiment.
[0022] Figure 6 This is a block diagram illustrating a server according to an exemplary embodiment. Detailed Implementation
[0023] The specific embodiments of this disclosure will be described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are for illustration and explanation only and are not intended to limit this disclosure.
[0024] The specific embodiments of this disclosure will be described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are for illustration and explanation only and are not intended to limit this disclosure.
[0025] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.
[0026] It should be understood that the steps described in the method embodiments of this disclosure may be performed in different orders and / or in parallel. Furthermore, the method embodiments may include additional steps and / or omit the steps shown. The scope of this disclosure is not limited in this respect.
[0027] The term "comprising" and its variations as used herein are open-ended inclusions, meaning "including but not limited to". The term "based on" means "at least partially based on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". Definitions of other terms will be given in the description below.
[0028] It should be noted that the concepts of "first" and "second" mentioned in this disclosure are used only to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units or their interdependencies.
[0029] Please refer to the relevant technologies. Figure 1 , Figure 1 A schematic diagram of debugging based on a GPU module is shown. Figure 1 In this architecture, the BMC (Brain Management Center) houses a GPU module monitoring module. Within the GPU module, a management controller acts as a communication bridge between the monitoring module and the individual GPUs, network interface cards (NICs), and other components. The management controller receives monitoring commands from the BMC's GPU module monitoring module and forwards them to the corresponding GPU or NIC device. Simultaneously, it collects operational status data from each device within the GPU module and transmits it back to the BMC for centralized monitoring and analysis. This architecture enables real-time acquisition and dynamic control of key parameters such as GPU computing power utilization, temperature, power consumption, and NIC communication status. However, in servers without GPU modules, the lack of a GPU module and corresponding management controller makes it impossible to monitor and control GPU-related parameters using the existing architecture, hindering system maintenance personnel from obtaining the operational status of critical hardware.
[0030] To address the technical problems mentioned in the background section and the aforementioned technical issues, this application discloses a debugging method. Figure 2This is a flowchart illustrating a debugging method according to an exemplary embodiment. The method is applied to a server without a GPU module. The server includes a simulated GPU module response module, which responds to requested data. It is understood that a GPU module refers to a graphics processing unit (GPU) module, used for tasks such as graphics rendering, parallel computing, and deep learning. In this embodiment, the simulated GPU module response module simulates the function of the management controller in an actual GPU module, receives requested data from a debugging terminal, and generates corresponding response information according to preset rules to achieve functional verification and communication protocol testing of the server without a GPU module. This simulation mechanism does not rely on physical GPU hardware, reducing the complexity and cost of setting up the debugging environment while improving debugging efficiency and repeatability. The method may include the following steps.
[0031] In step S11, the GPU module monitoring module in the server sends interface request data to the simulated GPU module response module.
[0032] The GPU module monitoring module is a software unit used to monitor and manage the operating status of the simulated GPU module response module in real time. It has the functions of collecting response latency, processing request frequency, and recording communication logs.
[0033] Furthermore, the interface request data includes, but is not limited to, interface request type, data packet size, target address, and timestamp information, used to simulate communication load in real-world scenarios.
[0034] In this embodiment, the GPU module monitoring module sends interface request data to the simulated GPU module response module via a network interface using a preset communication protocol and an asynchronous message queue, ensuring that the interface request data is transmitted in an orderly manner according to priority. Alternatively, the sending method can be implemented through shared memory mapping combined with an event-triggered mechanism, suitable for real-time interaction requirements in high-throughput scenarios. The sending method can also be completed through a direct memory access (DMA) channel combined with a polling mechanism to reduce CPU intervention overhead and improve the real-time performance of data transmission. Different sending methods can be dynamically switched according to system architecture and performance requirements to ensure the stability and efficiency of communication during debugging. It is understood that the GPU module monitoring module and the simulated GPU module response module can be located on the same server or on different servers. When the GPU module monitoring module and the simulated GPU module response module are located on the same server, they can send and receive interface request data through an inter-process communication mechanism. When the GPU module monitoring module and the simulated GPU module response module are located on different servers, they interact with each other through a network communication protocol.
[0035] For example, when the GPU module monitoring module and the simulated GPU module response module are set on the same server, the GPU module monitoring module configures the target IP and port to port 8080 of 127.0.0.1, and the simulated GPU module response module also continuously listens for interface request data on port 8080 and communicates using the local port 8080, without affecting the original HTTP port (port 80) communication function. When the GPU module monitoring module and the simulated GPU module response module are set on different servers, the GPU module monitoring module is still located inside the BMC, but the simulated GPU module response module is deployed on an external server. This method communicates based on the physical network link, which is more in line with the actual scenario and verifies the function more comprehensively. The GPU module monitoring module configures the target IP and port to port 80 of the external server IP, and the simulated GPU module response module also continuously listens for interface request data to port 80 of the corresponding IP of all network cards on the local machine.
[0036] In step S12, the response data fed back by the simulated GPU module response module based on the interface request data is received.
[0037] Among them, response data refers to the feedback information generated by the simulated GPU module response module based on the interface request data, which parses the request type and parameter information and generates according to preset rules, including status code, response latency and data load. It can be used to verify the integrity of the communication link and the accuracy of protocol parsing.
[0038] In step S13, the GPU module monitoring module is debugged based on the response data.
[0039] One approach is to directly debug the GPU module monitoring module based on the response data. Debugging can be done by determining if communication is normal based on the status codes in the response data, and if anomalies are found, by combining timestamps and log information to pinpoint the fault. Another approach is to assess system load capacity based on response latency metrics, construct performance trend charts using historical data, identify potential bottlenecks, and optimize resource scheduling strategies. A third approach is to verify protocol compatibility and data integrity by comparing load consistency and transmission error rates across multiple rounds of response data, and then adjust buffer size or retransmission mechanisms to improve communication reliability.
[0040] Furthermore, the response data can be parsed, and the GPU module monitoring module can be debugged based on the parsed response data. Parsing methods can include decoding layer by layer based on a predefined protocol format to extract status fields, latency markers, and data payloads. Alternatively, parsing can employ verification algorithms to check data integrity and combine contextual semantic analysis to identify abnormal response patterns. Debugging can involve triggering corresponding diagnostic processes based on the parsed status fields. If a protocol format mismatch or verification failure is detected, a fault tolerance mechanism is activated and abnormal events are recorded in the log system. This allows for adjustments to the GPU module monitoring module based on the log system's logs. Debugging can also involve performance analysis based on the parsed latency markers, dynamically adjusting the communication polling frequency and data packet size based on load fluctuations to optimize transmission efficiency. Finally, for the parsed data payload, the logical correctness can be judged by comparing it with the expected response content. If data deviations are found, an error correction mechanism is activated and feedback is sent to the protocol layer for correction, ensuring stable operation and high reliability of the system under complex operating conditions.
[0041] In this solution, by deploying a simulated GPU module response module in a server without a physical GPU module, the response data corresponding to the interface request data can be accurately obtained. Based on the response data, the GPU module monitoring module can be debugged, which can effectively simulate the communication behavior of a real GPU module. This significantly reduces the cost of setting up the debugging environment and hardware dependence, and provides reliable support for communication protocol verification and system performance optimization.
[0042] Figure 3 This is a flowchart illustrating a debugging method according to another exemplary embodiment, which may include the following steps.
[0043] In step S21, the communication IP information and communication port information of the simulated GPU module response module are obtained through the GPU module monitoring module.
[0044] The communication IP information includes, but is not limited to, the server's IP address information and the IP address information of the network environment where the simulated GPU module response module is located. The communication port information includes, but is not limited to, the communication port information opened by the server and the port information listened to by the simulated GPU module response module.
[0045] In this embodiment, the communication IP information and communication port information can be obtained in real time, or the communication IP information and communication port information of the simulated GPU module response module can be configured in a JSON file beforehand. The GPU module monitoring module then obtains the communication IP information and communication port information of the simulated GPU module response module by retrieving the JSON file. The configuration method can be flexibly selected according to the actual deployment environment to ensure that the GPU module monitoring module can accurately establish a communication link with the simulated GPU module response module. Obtaining the communication IP information and communication port information of the simulated GPU module response module can be used for subsequent target address and port configuration when establishing network connections, ensuring that data packets are accurately routed to the simulated module.
[0046] In step S22, the GPU module monitoring module in the server sends interface request data to the simulated GPU module response module.
[0047] In step S23, the response data fed back by the simulated GPU module response module based on the interface request data is received.
[0048] For a detailed explanation of steps S22 to S23, please refer to the detailed explanation of steps S11 to S12 in the foregoing embodiments, which will not be repeated here.
[0049] In some implementations, after receiving the response data from the simulated GPU module response module based on the interface request data, the method further includes: parsing the response data to obtain parsed response data. The step of debugging the GPU module monitoring module based on the response data includes: debugging the GPU module monitoring module based on the parsed response data.
[0050] In this implementation, the parsing process may include data format verification, key field extraction, and anomaly code identification to ensure that the response data conforms to a predefined communication protocol format. If the verification passes, key status parameters, such as GPU load, temperature, and video memory usage, are extracted and combined with the anomaly code to determine whether the module is operating normally. If an anomaly code or data format error is detected, an alarm mechanism is triggered and logs are recorded for subsequent analysis and problem localization. During the debugging process, the monitoring strategy is dynamically adjusted based on the parsing results to improve system stability and real-time performance.
[0051] In step S24, a GPU response dataset is obtained, which includes multiple Redfish interfaces and preset response data corresponding to each Redfish interface.
[0052] The GPU response dataset includes, but is not limited to, the Redfish specifications of GPU modules provided by GPU manufacturers. Based on these specifications, the Redfish interfaces and fields to be monitored are determined, resulting in the GPU response dataset. To better utilize this dataset, these interfaces and fields can be categorized according to different components within the GPU module (e.g., GPU, network interface card) and / or interface types (e.g., GET, PATCH, POST), and saved to a JSON file for easy loading and retrieval on demand. Categorized management improves interface lookup efficiency, supports modular configuration and dynamic updates, and ensures the monitoring system maintains good maintainability and scalability even in complex deployment environments. By loading the JSON configuration file, the system can dynamically initialize monitoring tasks and execute corresponding request strategies and parsing rules for different interface types. Combined with preset response data, an automated comparison mechanism is built to verify the consistency between actual responses and expected results, promptly detecting protocol deviations or functional anomalies.
[0053] In step S25, based on the interface request data, preset response data corresponding to the interface request data is determined from the GPU response dataset.
[0054] One method for determining the preset response data is to match the corresponding interface in the interface request data with the interfaces in the GPU response dataset. Once a matching interface is found, the preset response data is then determined from the GPU response dataset based on that interface. Another method is to match the function identifier and protocol version information in the interface request data with the metadata index of the GPU response dataset to locate the corresponding preset response data. A third method is to establish a mapping relationship between the interface request data and the preset response data using a hash table, and then quickly retrieve the preset response data based on the hash value corresponding to the interface request data, improving matching efficiency and system response speed. No specific method is limited here.
[0055] In step S26, the GPU module monitoring module is debugged based on the response data and the preset response data.
[0056] The debugging methods for adjusting the GPU module monitoring module based on response data and preset response data can include debugging based on the consistency of the response data and preset response data, calibrating the fault tolerance threshold based on the difference between the response data and preset response data, and analyzing the response stability of the monitoring module through historical data comparison. Furthermore, by setting a dynamic fault tolerance threshold, it can adapt to data fluctuations under different load scenarios, avoiding false alarms and missed alarms.
[0057] In some implementations, debugging the GPU module monitoring module based on the response data and the preset response data includes: debugging the GPU module monitoring module based on the consistency between the response data and the preset response data.
[0058] Consistency checks include, but are not limited to, one or more of the following: field consistency, data type consistency, or value range consistency. Field consistency checks ensure that the actual response contains the preset fields and has no extra fields; data type consistency checks return values that match the preset format; and value range consistency checks whether key parameters such as temperature and load are within a reasonable range. Through multi-dimensional consistency comparisons, data deviations and protocol violations are accurately identified, improving debugging accuracy and system robustness.
[0059] In this embodiment, when the actual response data deviates from the preset response data in terms of fields, types, or values, the system automatically triggers an alarm and records the abnormal context, making it easier to quickly locate the root cause of the problem.
[0060] In some specific implementations, debugging the GPU module monitoring module based on the consistency between the response data and the preset response data includes: determining that the GPU module monitoring module is functioning normally when the response data is the same as the preset response data; and determining that the GPU module monitoring module is functioning abnormally when the response data is different from the preset response data.
[0061] In this implementation, when the response data matches the preset response data, the monitoring module is considered to be operating normally, and no alarm or intervention mechanism needs to be triggered. When the response data differs from the preset response data, the interface can be automatically marked as abnormal, the difference fields and timestamps can be recorded, and an alarm process can be triggered to notify maintenance personnel or activate a preset fault recovery strategy, ensuring that the problem is traceable and manageable. The alarm information includes the abnormal interface name, a comparison of the expected and actual values, the GPU module number and location, facilitating rapid identification of the problem source. Historical abnormal data can also be stored in a database for subsequent trend analysis and optimization of monitoring strategies. Simultaneously, machine learning models can be used to classify and identify abnormal patterns, improving fault prediction capabilities. During debugging, simulated response data can be manually injected to verify the correctness of the alarm logic. This allows for closed-loop debugging of the GPU module monitoring module's own reliability, ensuring that the monitoring data is accurate and reliable, and that it operates stably under various operating conditions.
[0062] For specific implementation details, please refer to [link / reference]. Figure 4 , Figure 4The diagram illustrates the debugging process of the GPU module monitoring module in the absence of a GPU module. In a scenario without a connected GPU module, the GPU module monitoring module acquires the communication IP and port information of the simulated GPU module response module. Based on this IP and port, it sends interface request data to the simulated GPU module response module, receives response data returned by the simulated GPU module response module, and debugs the GPU module monitoring module based on the consistency between the response data and preset response data, verifying its functional integrity and communication stability in the absence of real hardware.
[0063] This solution can accurately identify functional abnormalities and data deviations of the GPU module monitoring module by flexibly acquiring communication configurations, parsing verification response data, and comparing with preset datasets in multiple dimensions. It also supports dynamic debugging and strategy optimization, effectively improving the stability, maintainability, and fault location efficiency of the monitoring system.
[0064] Based on the same inventive concept, this disclosure also provides a debugging device. Figure 5 This is a block diagram illustrating a debugging apparatus according to an exemplary embodiment. The debugging apparatus 300 is applied to a server without a GPU module, the server including a simulated GPU module response module for responding to requested data, such as... Figure 5 As shown, the debugging device 300 may include a data sending unit 310, a data receiving unit 320, and a module debugging unit 330, wherein, The data sending unit 310 is configured to send interface request data to the simulated GPU module response module through the GPU module monitoring module in the server; The data receiving unit 320 is configured to receive response data from the simulated GPU module response module based on the interface request data. The module debugging unit 330 is configured to debug the GPU module monitoring module based on the response data.
[0065] In one possible implementation, the module debugging unit 330 is further configured to acquire a GPU response dataset, the GPU response dataset including multiple Redfish interfaces and preset response data corresponding to each Redfish interface; Based on the interface request data, determine the preset response data corresponding to the interface request data from the GPU response dataset; The GPU module monitoring module is debugged based on the response data and the preset response data.
[0066] In one possible implementation, the module debugging unit 330 is further configured to debug the GPU module monitoring module based on the consistency between the response data and the preset response data.
[0067] In one possible implementation, the module debugging unit 330 is further configured to determine that the GPU module monitoring module is functioning normally if the response data is the same as the preset response data. If the response data is different from the preset response data, the function of the GPU module monitoring module is determined to be abnormal.
[0068] In one possible implementation, the debugging device 300 further includes a data parsing unit configured to parse the response data to obtain parsed response data. The module debugging unit 330 is also configured to debug the GPU module monitoring module based on the parsed response data.
[0069] In one possible implementation, the debugging device 300 further includes an information acquisition unit configured to acquire the communication IP information and communication port information of the simulated GPU module response module.
[0070] Figure 6 This is a block diagram illustrating a server according to an exemplary embodiment. Figure 6 As shown, the server 400 may include: a GPU module monitoring module; a simulated GPU module response module for responding to requested data; a processor 401; and a memory 402. The server 400 may also include one or more of the following: a multimedia component 403, an input / output (I / O) interface 404, and a communication component 405.
[0071] The processor 401 controls the overall operation of the server 400 to complete all or part of the steps in the aforementioned debugging method. The memory 402 stores various types of data to support the operation of the server 400. This data may include, for example, instructions for any application or method operating on the server 400, and application-related data such as contact data, sent and received messages, images, audio, video, etc. The memory 402 can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read-Only Memory (EPROM), Programmable Read-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. The multimedia component 403 may include a screen and audio components. The screen may be, for example, a touchscreen, and the audio component is used for outputting and / or inputting audio signals. For example, the audio component may include a microphone for receiving external audio signals. The received audio signals may be further stored in memory 402 or transmitted via communication component 405. The audio component also includes at least one speaker for outputting audio signals. I / O interface 404 provides an interface between processor 401 and other interface modules, such as a keyboard, mouse, buttons, etc. These buttons may be virtual or physical buttons. Communication component 405 is used for wired or wireless communication between server 400 and other devices. Wireless communication may include Wi-Fi, Bluetooth, Near Field Communication (NFC), 2G, 3G, or 4G, or a combination of these. Therefore, the corresponding communication component 405 may include a Wi-Fi module, a Bluetooth module, or an NFC module.
[0072] In an exemplary embodiment, server 400 may be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field-programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors, or other electronic components to perform the debugging method described above.
[0073] In another exemplary embodiment, a computer-readable storage medium including program instructions is also provided, which, when executed by a processor, implement the steps of the debugging method described above. For example, the computer-readable storage medium may be the memory 402 including the program instructions described above, which may be executed by the processor 401 of the server 400 to complete the debugging method described above.
[0074] In another exemplary embodiment, a computer program product is also provided, which includes a computer program executable by a processor, which, when executed by the processor, implements the steps of the debugging method described above.
[0075] The preferred embodiments of this disclosure have been described in detail above with reference to the accompanying drawings. However, this disclosure is not limited to the specific details of the above embodiments. Within the scope of the technical concept of this disclosure, various simple modifications can be made to the technical solutions of this disclosure, and these simple modifications all fall within the protection scope of this disclosure.
[0076] It should also be noted that the various specific technical features described in the above specific embodiments can be combined in any suitable manner without contradiction. In order to avoid unnecessary repetition, this disclosure will not describe the various possible combinations separately.
[0077] Furthermore, various different embodiments of this disclosure can be combined in any way, as long as they do not violate the spirit of this disclosure, they should also be regarded as the content disclosed in this disclosure.
Claims
1. A debugging method, characterized in that, An application to a server without a GPU module, the server including a simulated GPU module response module for responding to requested data, the method comprising: The GPU module monitoring module in the server sends interface request data to the simulated GPU module response module. Receive response data from the simulated GPU module response module based on the interface request data; The GPU module monitoring module is debugged based on the response data.
2. The debugging method according to claim 1, characterized in that, The step of debugging the GPU module monitoring module based on the response data includes: Obtain the GPU response dataset, which includes multiple Redfish interfaces and preset response data corresponding to each Redfish interface; Based on the interface request data, determine the preset response data corresponding to the interface request data from the GPU response dataset; The GPU module monitoring module is debugged based on the response data and the preset response data.
3. The debugging method according to claim 2, characterized in that, The step of debugging the GPU module monitoring module based on the response data and the preset response data includes: The GPU module monitoring module is debugged based on the consistency between the response data and the preset response data.
4. The debugging method according to claim 3, characterized in that, The step of debugging the GPU module monitoring module based on the consistency between the response data and the preset response data includes: If the response data is the same as the preset response data, it is determined that the GPU module monitoring module is functioning normally. If the response data is different from the preset response data, the function of the GPU module monitoring module is determined to be abnormal.
5. The debugging method according to claim 1, characterized in that, After receiving the response data from the simulated GPU module response module based on the interface request data, the method further includes: The response data is parsed to obtain the parsed response data; The step of debugging the GPU module monitoring module based on the response data includes: The GPU module monitoring module is debugged based on the parsed response data.
6. The debugging method according to any one of claims 1-5, characterized in that, Before the GPU module monitoring module in the server sends interface request data to the simulated GPU module response module, the method further includes: Obtain the communication IP information and communication port information of the simulated GPU module response module.
7. A debugging device, characterized in that, An apparatus for use in servers without GPU modules, the server including a simulated GPU module response module for responding to requested data, the apparatus comprising: The data sending unit is configured to send interface request data to the simulated GPU module response module through the GPU module monitoring module in the server; The data receiving unit is configured to receive response data from the simulated GPU module response module based on the interface request data feedback. The module debugging unit is configured to debug the GPU module monitoring module based on the response data.
8. A server, characterized in that, include: GPU module monitoring module; A simulated GPU module response module is used to respond to requested data; A memory on which computer programs are stored; A processor for executing the computer program in the memory to implement the steps of the method according to any one of claims 1-6.
9. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the program implements the steps of the method described in any one of claims 1-6.
10. A computer program product, comprising a computer program, characterized in that, When executed by a processor, the computer program implements the steps of the method described in any one of claims 1-6.