CN114676006B - System self-checking method, device, equipment and storage medium based on dynamic reconfiguration - Google Patents
System self-checking method, device, equipment and storage medium based on dynamic reconfiguration Download PDFInfo
- Publication number
- CN114676006B CN114676006B CN202210274551.1A CN202210274551A CN114676006B CN 114676006 B CN114676006 B CN 114676006B CN 202210274551 A CN202210274551 A CN 202210274551A CN 114676006 B CN114676006 B CN 114676006B
- Authority
- CN
- China
- Prior art keywords
- system self
- self
- checking
- error codes
- derivation rule
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/2289—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing by configuration test
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/2273—Test methods
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/25—Testing of logic operation, e.g. by logic analysers
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3055—Monitoring arrangements for monitoring the status of the computing system or of the computing system component, e.g. monitoring if the computing system is on, off, available, not available
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Computing Systems (AREA)
- Test And Diagnosis Of Digital Computers (AREA)
Abstract
The invention discloses a system self-checking method, a device, equipment and a storage medium based on dynamic reconfiguration, wherein the method comprises the steps of acquiring configurable data of historical system self-checking and generating a system self-checking derivation rule set; converting the system state data into a plurality of target error codes, and storing the plurality of target error codes; when a system self-check instruction is received, traversing each system self-check derivation rule in the system self-check derivation rule set, and judging whether a plurality of target error codes stored in the current system meet the error codes and logic relations corresponding to the system self-check derivation rules; and if so, outputting fault information corresponding to the system self-checking derivation rule. According to the method, the system self-check derivation rule set is generated according to historical configurable data, and the acquired current state data of the system are matched with the error codes corresponding to the system self-check derivation rule set, so that the system self-check of dynamic reconstruction is realized, the transportability and light weight of the system self-check are realized, and the system self-check efficiency is improved.
Description
Technical Field
The present invention relates to the field of data processing technologies, and in particular, to a system self-checking method, apparatus, device, and storage medium based on dynamic reconfiguration.
Background
Aiming at the self-checking function or the fault detection function, a special pertinence requirement is often provided for a certain project and a certain type of equipment, and at present, no uniform index, standard and standard of the industry exist. However, the self-checking function implies reliability and maintainability indexes, and if the software self-checking function is complete, the fault is easy to locate and eliminate, and the equipment development, joint test and maintenance time can be shortened.
In the process of developing equipment, software is larger and larger, interaction relationships are more and more, logic processing is more and more complex, and most functions of the equipment need to be realized by software. The self-checking function capable of quickly checking system function errors and hardware problems becomes more and more important, but because a simple and easily-transplanted self-checking scheme is lacked, the self-checking difficulty of a complex system is high, and the effects of positioning and isolating problems of the self-checking function are not obvious.
The conventional self-checking scheme is shown in fig. 1 and mainly includes data acquisition, data judgment, fault detection and fault reporting.
The above scheme has the following problems:
(1) The self-checking function is usually strongly coupled with the hardware composition and the working principle of the equipment, and is often designed according to a specific system, and the fault detection and fault isolation in the self-checking program relate to complex judgment logic, are difficult to expand and transplant, and are difficult to realize the generalization of self-checking function software;
(2) The self-checking function is developed in a forward direction, fault judgment can be carried out only after all data are acquired, the self-checking function can be carried out only in the later stage of demand development, and rapid iterative development and verification are difficult to carry out;
(3) The complexity of the self-checking function is exponentially increased along with the increase of the types of system faults, the realization difficulty is high, and due to the complex logic, the requirement change easily causes a large amount of design modification, the software quality is influenced, and the maintenance is extremely difficult.
(4) The existing part of equipment reports less fault information, and fault detail information is difficult to reflect, so that the fault information is not reported.
Therefore, how to realize the portability and light weight of the system self-checking and improve the system self-checking efficiency is a technical problem which needs to be solved urgently.
The above is only for the purpose of assisting understanding of the technical aspects of the present invention, and does not represent an admission that the above is prior art.
Disclosure of Invention
The invention mainly aims to provide a system self-checking method, a device, equipment and a storage medium based on dynamic reconfiguration, and aims to solve the technical problems of poor system self-checking portability, complex logic and low self-checking efficiency in the prior art.
In order to achieve the above object, the present invention provides a system self-checking method based on dynamic reconfiguration, which comprises the following steps:
acquiring configurable data of self-checking of a historical system, and generating a system self-checking derivation rule set according to the configurable data; the system self-test derivation rule set comprises a plurality of system self-test derivation rules, and each system self-test derivation rule stores a plurality of error codes and a logic relation corresponding to each error code;
when system state data are received, converting the system state data into a plurality of target error codes, and storing the plurality of target error codes;
when a system self-check instruction is received, traversing each system self-check derivation rule in the system self-check derivation rule set, and judging whether a plurality of target error codes stored in the current system meet the error codes and logic relations corresponding to the system self-check derivation rules;
and if so, outputting fault information corresponding to the system self-checking derivation rule.
Optionally, the expression of the system self-test derivation rule is:
rule＝{(errCode,Con)}；
wherein, the errCode error code, con is defined as the logical relationship of the error code.
Optionally, the logical relationship includes a relational and, a relational or a relational negation.
Optionally, when a system self-test instruction is received, traversing each system self-test derivation rule in the system self-test derivation rule set, and determining whether a plurality of target error codes stored in the current system satisfy the error codes and logical relationship steps corresponding to the system self-test derivation rule, specifically including:
traversing and extracting one system self-check derivation rule in the system self-check derivation rule set when a system self-check instruction is received;
judging whether a target error code stored by the current system meets the error code and logic relation corresponding to the system self-checking derivation rule;
if yes, outputting fault information corresponding to the system self-checking derivation rule;
if not, extracting the next system self-check derivation rule in the system self-check derivation rule set, and executing the step of judging whether a plurality of target error codes stored in the current system meet the error codes and the logical relation corresponding to the system self-check derivation rule until the system self-check derivation rule in the system self-check derivation rule set is traversed.
Optionally, the determining whether a plurality of target error codes stored in the current system satisfy the error codes and the logical relationship corresponding to the system self-test derivation rule specifically includes:
if the error codes of the system self-checking derivation rule meet the matching condition, judging that a plurality of target error codes stored in the current system meet the error codes and logic relations corresponding to the system self-checking derivation rule;
the matching conditions are that the logic and the corresponding error codes can be matched in the target error codes, the logic non-corresponding error codes cannot be matched in the target error codes, and the logic or the corresponding error codes can be matched or cannot be matched in the target error codes.
Optionally, the system status data includes software running status data and/or hardware running status data, and the error code includes one or more of a software module number, a hardware module number, an object type, an object number, a custom field, an error prompt, and an error type.
Optionally, the target error code is stored by using a data structure of a red-black tree or a Hash table.
In addition, in order to achieve the above object, the present invention further provides a system self-test apparatus based on dynamic reconfiguration, including:
the generation module is used for acquiring configurable data of the self-test of the historical system and generating a system self-test derivation rule set according to the configurable data; the system self-test derivation rule set comprises a plurality of system self-test derivation rules, and each system self-test derivation rule stores a plurality of error codes and a logical relation corresponding to each error code;
the conversion module is used for converting the system state data into a plurality of target error codes and storing the target error codes when the system state data is received;
the judging module is used for traversing each system self-check derivation rule in the system self-check derivation rule set when a system self-check instruction is received, and judging whether a plurality of target error codes stored in the current system meet the error codes and the logic relation corresponding to the system self-check derivation rule;
and the output module is used for outputting the fault information corresponding to the system self-checking derivation rule if the fault information meets the requirement.
In addition, in order to achieve the above object, the present invention further provides a system self-test apparatus based on dynamic reconfiguration, the apparatus including: the system self-checking method comprises a memory, a processor and a system self-checking program based on dynamic reconfiguration, wherein the system self-checking program based on dynamic reconfiguration is stored in the memory and can run on the processor, and when being executed by the processor, the system self-checking program based on dynamic reconfiguration realizes the steps of the system self-checking method based on dynamic reconfiguration.
In addition, in order to achieve the above object, the present invention further provides a storage medium, where a system self-test program based on dynamic reconfiguration is stored, and when the system self-test program based on dynamic reconfiguration is executed by a processor, the steps of the system self-test method based on dynamic reconfiguration are implemented.
The proposal of the invention has the following beneficial effects:
and (4) fast transplanting a self-checking function: the self-checking function is decoupled from the hardware composition and the working principle of specific equipment by a modular design method, the method supports quick transplantation in different systems and different equipment, and the universality is high.
And (3) fast reconstruction of self-checking function: through the derivation rule configurable design, when the self-checking object and the self-checking rule are changed, the system architecture and algorithm are not required to be changed, only the configuration data is modified to adapt to the requirement change, and the expansibility is strong.
The self-checking functional design is simplified: when a system fault is judged according to a certain derivation rule, only the logical AND condition and the logical NOT condition of the error code related to the rule are concerned, the logical OR condition is ignored, and the states of all objects do not need to be collected, so that self-checking development and verification can be carried out at the early stage of function development and iteration is carried out continuously.
Self-checking development efficiency promotes: through error code abstraction, fault discrimination logic is isolated from concrete software and hardware states, multiple error state representations of various software and hardware can be supported, when each system derives the method, only error code generation and reporting function development are needed to be completed, other functions can be completely multiplexed, and development efficiency and quality are improved.
Drawings
FIG. 1 is a schematic diagram of a conventional system self-test;
FIG. 2 is a schematic structural diagram of a system self-test device based on dynamic reconfiguration according to an embodiment of the present invention;
FIG. 3 is a schematic flow chart illustrating a system self-checking method based on dynamic reconfiguration according to an embodiment of the present invention;
FIG. 4 is a schematic diagram illustrating a system self-test based on dynamic reconfiguration according to an embodiment of the present invention;
FIG. 5 is a diagram illustrating the storage of target error codes in an embodiment of the present invention;
fig. 6 is a block diagram of a system self-checking device based on dynamic reconfiguration according to an embodiment of the present invention.
The implementation, functional features and advantages of the objects of the present invention will be further explained with reference to the accompanying drawings.
Detailed Description
It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.
First, before describing the embodiments of the present application, the related contents of the embodiments of the present application with respect to the application context will be described.
Aiming at the self-checking function or the fault detection function, a special pertinence requirement is often provided for a certain project and a certain type of equipment, and at present, no uniform index, standard and standard of the industry exist. However, the self-checking function implies reliability and maintainability indexes, and if the software self-checking function is complete, the fault is easy to locate and eliminate, and the equipment development, joint test and maintenance time can be shortened.
In the process of developing equipment, software is larger and larger, interaction is more and more, logic processing is more and more complex, and most functions of the equipment need to be realized by the software. The self-checking function capable of quickly checking system function errors and hardware problems becomes more and more important, but because a simple and easily-transplanted self-checking scheme is lacked, the self-checking difficulty of a complex system is high, and the effects of positioning and isolating problems of the self-checking function are not obvious.
The conventional self-checking scheme is shown in fig. 1 and mainly includes data acquisition, data judgment, fault detection and fault reporting.
The above scheme has the following problems: the self-checking function is usually strongly coupled with the hardware composition and the working principle of the equipment, and is often designed according to a specific system, and the fault detection and fault isolation in the self-checking program relate to complex judgment logic, are difficult to expand and transplant, and are difficult to realize the generalization of self-checking function software; the self-checking function is developed in a forward direction, fault judgment can be carried out only after all data are acquired, the self-checking function can be carried out only in the later stage of demand development, and rapid iterative development and verification are difficult to carry out; the complexity of the self-checking function is exponentially increased along with the increase of the types of system faults, the realization difficulty is high, and due to the complex logic, the requirement change easily causes a large amount of design modification, the software quality is influenced, and the maintenance is extremely difficult. The existing part of equipment reports less fault information, and fault detail information is difficult to reflect, so that the fault information is not reported.
Therefore, how to realize the portability and light weight of the system self-checking and improve the system self-checking efficiency is a technical problem which needs to be solved urgently.
To address this issue, various embodiments of the system self-test method based on dynamic reconstruction of the present invention are presented. The system self-checking method based on dynamic reconfiguration provided by the invention generates a system self-checking derivation rule set by acquiring configurable data of the self-checking of a historical system; converting the system state data into a plurality of target error codes, and storing the plurality of target error codes; when a system self-check instruction is received, traversing each system self-check derivation rule in the system self-check derivation rule set, and judging whether a plurality of target error codes stored in the current system meet the error codes and logic relations corresponding to the system self-check derivation rules; and if so, outputting fault information corresponding to the system self-checking derivation rule. According to the method, the system self-check derivation rule set is generated according to historical configurable data, and the acquired current state data of the system are matched with the error codes corresponding to the system self-check derivation rule set, so that the system self-check of dynamic reconstruction is realized, the transportability and light weight of the system self-check are realized, and the system self-check efficiency is improved.
Referring to fig. 2, fig. 2 is a schematic structural diagram of a system self-checking device based on dynamic reconfiguration according to an embodiment of the present invention.
The device may be a User Equipment (UE) such as a Mobile phone, a smart phone, a laptop, a digital broadcast receiver, a Personal Digital Assistant (PDA), a tablet computer (PAD), etc. located on an airplane, a handheld device, a vehicle-mounted device, a wearable device, a computing device or other processing device connected to a wireless modem, a Mobile Station (MS), etc. The device may be referred to as a user terminal, portable terminal, desktop terminal, etc.
Generally, the apparatus comprises: at least one processor 301, a memory 302, and a dynamic reconfiguration based system self-test program stored on the memory and executable on the processor, the dynamic reconfiguration based system self-test program being configured to implement the steps of the dynamic reconfiguration based system self-test method as described above.
The processor 301 may include one or more processing cores, such as a 4-core processor, an 8-core processor, and so on. The processor 301 may be implemented in at least one hardware form of a DSP (Digital Signal Processing), an FPGA (Field-Programmable Gate Array), and a PLA (Programmable Logic Array). The processor 301 may also include a main processor and a coprocessor, where the main processor is a processor for processing data in an awake state, and is also called a Central Processing Unit (CPU); a coprocessor is a low power processor for processing data in a standby state. In some embodiments, the processor 301 may be integrated with a GPU (Graphics Processing Unit), which is responsible for rendering and drawing the content required to be displayed on the display screen. The processor 301 may further include an AI (Artificial Intelligence) processor for processing operations related to the system self-test based on dynamic reconfiguration, so that the system self-test model based on dynamic reconfiguration may be trained and learned autonomously, thereby improving efficiency and accuracy.
In some embodiments, the terminal may further include: a communication interface 303 and at least one peripheral device. The processor 301, the memory 302 and the communication interface 303 may be connected by a bus or signal lines. Various peripheral devices may be connected to communication interface 303 via a bus, signal line, or circuit board. Specifically, the peripheral device includes: at least one of radio frequency circuitry 304, a display screen 305, and a power source 306.
The communication interface 303 may be used to connect at least one peripheral device related to I/O (Input/Output) to the processor 301 and the memory 302. The communication interface 303 is used for receiving the movement tracks of the plurality of mobile terminals uploaded by the user and other data through the peripheral device. In some embodiments, processor 301, memory 302, and communication interface 303 are integrated on the same chip or circuit board; in some other embodiments, any one or two of the processor 301, the memory 302 and the communication interface 303 may be implemented on a single chip or circuit board, which is not limited by the embodiment.
The Radio Frequency circuit 304 is used for receiving and transmitting RF (Radio Frequency) signals, also called electromagnetic signals. The radio frequency circuit 304 communicates with a communication network and other communication devices through electromagnetic signals, so as to obtain the movement tracks and other data of a plurality of mobile terminals. The rf circuit 304 converts an electrical signal into an electromagnetic signal to transmit, or converts a received electromagnetic signal into an electrical signal. Optionally, the radio frequency circuit 304 comprises: an antenna system, an RF transceiver, one or more amplifiers, a tuner, an oscillator, a digital signal processor, a codec chipset, a subscriber identity module card, and so forth. The radio frequency circuitry 304 may communicate with other terminals via at least one wireless communication protocol. The wireless communication protocols include, but are not limited to: metropolitan area networks, various generation mobile communication networks (2G, 3G, 4G, and 5G), wireless local area networks, and/or WiFi (Wireless Fidelity) networks. In some embodiments, the rf circuit 304 may further include NFC (Near Field Communication) related circuits, which are not limited in this application.
The display screen 305 is used to display a UI (User Interface). The UI may include graphics, text, icons, video, and any combination thereof. When the display screen 305 is a touch display screen, the display screen 305 also has the ability to capture touch signals on or over the surface of the display screen 305. The touch signal may be input to the processor 301 as a control signal for processing. At this point, the display screen 305 may also be used to provide virtual buttons and/or a virtual keyboard, also referred to as soft buttons and/or a soft keyboard. In some embodiments, the display screen 305 may be one, the front panel of the electronic device; in other embodiments, the display screens 305 may be at least two, respectively disposed on different surfaces of the electronic device or in a folded design; in still other embodiments, the display screen 305 may be a flexible display screen disposed on a curved surface or a folded surface of the electronic device. Even further, the display screen 305 may be arranged in a non-rectangular irregular figure, i.e. a shaped screen. The Display 305 may be made of LCD (liquid crystal Display), OLED (Organic Light-Emitting Diode), and the like.
The power supply 306 is used to power various components in the electronic device. The power source 306 may be alternating current, direct current, disposable or rechargeable. When the power source 306 includes a rechargeable battery, the rechargeable battery may support wired or wireless charging. The rechargeable battery may also be used to support fast charge technology.
Those skilled in the art will appreciate that the configuration shown in fig. 2 does not constitute a limitation of the system self-test apparatus based on dynamic reconfiguration, and may include more or fewer components than those shown, or some components in combination, or a different arrangement of components.
An embodiment of the present invention provides a system self-checking method based on dynamic reconfiguration, and referring to fig. 3, fig. 3 is a schematic flow chart of an embodiment of the system self-checking method based on dynamic reconfiguration according to the present invention.
In this embodiment, the system self-checking method based on dynamic reconfiguration includes the following steps:
step S100, acquiring configurable data of self-checking of a historical system, and generating a system self-checking derivation rule set according to the configurable data; the system self-test derivation rule set comprises a plurality of system self-test derivation rules, and each system self-test derivation rule stores a plurality of error codes and a logic relation corresponding to each error code.
Specifically, in practical applications, the configurable data of the historical system self-check can be obtained by stripping the fault judgment rule from the specific project and the specific work principle and converting the fault judgment rule into the configurable data. After that, the configurable data is read and analyzed to obtain a system self-check derivation rule set.
Further, the logical relationship includes a relational AND, a relational OR, and a relational NOT; each of the system self-check derivation rules may be expressed as rule = { (errCode, con) }, errCode error code, con being defined as the logical relationship { and, or, not } of error codes.
Step S200, when system state data is received, converting the system state data into a plurality of target error codes, and storing the plurality of target error codes.
Specifically, after a system self-inspection derivation rule set is generated, the system running state is monitored, system state data are obtained, the system state data are replaced by a plurality of target error codes, and the target error codes are stored.
In this embodiment, the system status data includes software running status data and/or hardware running status data, and the error code includes one or more of a software module number, a hardware module number, an object type, an object number, a custom field, an error prompt, and an error type.
When a plurality of target error codes are stored, a data structure of a red-black tree or a Hash table can be adopted for storage.
Step S300, when a system self-check instruction is received, traversing each system self-check derivation rule in the system self-check derivation rule set, and judging whether a plurality of target error codes stored in the current system meet the error codes and logic relations corresponding to the system self-check derivation rules.
Specifically, when a system self-check instruction is received, traversing and extracting one system self-check derivation rule in a system self-check derivation rule set; judging whether a target error code stored by the current system meets the error code and logic relation corresponding to the system self-checking derivation rule; if yes, outputting fault information corresponding to the system self-checking derivation rule; if the content is not satisfied, extracting the next system self-check derivation rule in the system self-check derivation rule set, and executing the step of judging whether a plurality of target error codes stored by the current system meet the error codes and the logical relation corresponding to the system self-checking derivation rule or not until the system self-checking derivation rule in the system self-checking derivation rule set is traversed and completed.
In this embodiment, whether a plurality of target error codes stored in the current system satisfy the error codes and the logical relationship corresponding to the system self-test derivation rule may be determined by: and if the error codes of the system self-inspection derivation rule meet the matching condition, judging that a plurality of target error codes stored in the current system meet the error codes and the logic relation corresponding to the system self-inspection derivation rule.
It is easy to understand that, in the present embodiment, the matching condition is that the logic and the corresponding error code can be matched in a plurality of target error codes, the logic non-corresponding error code cannot be matched in a plurality of target error codes, and the logic or the corresponding error code can be matched or cannot be matched in a plurality of target error codes.
And step S400, if the fault information is met, outputting fault information corresponding to the system self-checking derivation rule.
Specifically, after traversing each system self-check derivation rule in the system self-check derivation rule set to determine whether the target error code existing in the current system meets the requirements of the system self-check derivation rule, whether the system has a fault at present can be obtained according to the determination result.
That is, if the target error code corresponding to the state data of the current system matches the error code and the logical relationship in the system self-check derivation rule, it is determined that the current system has a fault corresponding to the system self-check derivation rule, the fault information is output at this time, and after all fault information is output, the self-check process of the current system is completed.
For convenience of understanding, the present embodiment provides a specific example of a system self-checking method based on dynamic reconstruction, which is specifically as follows:
referring to fig. 4, fig. 4 is a schematic diagram of the self-test of the system based on dynamic reconfiguration according to the embodiment. The system self-checking method based on dynamic reconfiguration can be realized through modules such as rule configuration data acquisition, derivation rule management, error code generation, error code management and fault detection based on the derivation rule.
Each module function and the design is briefly described as follows.
1. A rule configuration data acquisition module:
and stripping the fault judgment rule from the specific project and the specific work principle, and designing the fault judgment rule into configurable data. Configurable data forms include, but are not limited to, configuration files and databases. And when the system is initialized, reading and analyzing the configuration data. The rule of configuration is expressed as rule = { (errCode, con) }, errCode error code, con is defined as the logical relationship { and, or, not } of error codes. The rule configuration data design constraints are as follows:
(1) Supporting a plurality of rule configurations;
(2) The number of error codes configured by each rule is variable;
(3) The derivation of each error code configured by each rule supports logical relations of AND, OR, NOT, and NOT as follows:
and: when the query is indicated, an error code must exist in the error code management module;
or: when the query is expressed, the error code can exist or not exist;
not: when the query is indicated, the error code does not exist in the error code management module.
(4) The error codes configured in each rule support nesting, to generate complex logical relationships.
(5) The rules are automatically read when being powered on, and dynamic modification is supported;
(6) And completing fault detection and reporting according to the result of each deduction rule.
2. And a derivation rule management module:
and uniformly managing the configured rule data, providing an interface for an upper layer fault detection module, and acquiring a configured derivation rule. The support interfaces are as follows:
(1) Deducing rule query including quantity and content;
(2) Modifying a derivation rule;
(3) Deducing rule insertion;
(4) The derivation rule is deleted.
3. An error code generation module:
in the error code generation process, each software module and hardware module independently generate an error code, and in order to distinguish the error types of different software modules and different modules, the error codes can be represented by 32-bit or 64-bit shaping. The error codes generated by different error types of different modules cannot be repeated, global uniqueness must be ensured, and the definition of the error codes should include the following contents:
(1) Software module number: different software or different sub-modules in the software can be distinguished;
(2) Object type: such as a hardware module, a software module, or some functional item;
(3) Object number: to distinguish different instances of the same object type;
(4) Self-defining fields: to supplement content that cannot be uniquely distinguished by the present encoding scheme;
(5) Error indication, which indicates whether the error code value is abnormal or not, and is used for rapidly judging fault detection;
(6) Error type: such as temperature anomalies, voltage anomalies, and current anomalies.
The coding mode avoids the defect that many traditional self-checking schemes only can distinguish right and wrong but cannot display specific error types, and development and maintenance personnel can quickly locate the error reasons according to the error types.
The error code generation module supports the following interfaces:
(1) Creating an error code;
(2) And reporting the error code.
4. An error code management module:
and after the error code is generated, reporting the error code to an error code management module through a unified interface. To achieve fast querying of error codes, data structures including, but not limited to, a red-black tree and a Hash table are used for management. If the system design is complex, the error code to be managed is huge, and B _ Tree and B + _ Tree data structures can be collected for management. The error code management module needs to support the following interfaces:
(1) Error code queries, including quantity, definitions, etc.;
(2) Inserting an error code;
(3) Deleting the error code;
(4) The error code is cleared.
In some embodiments, the error code management module manages the error codes by using a red-black tree data structure, so as to realize quick query of the error codes during fault derivation. A typical balanced binary tree data structure is shown in fig. 5.
When the method is realized, after each software module collects data, status data is not directly reported to a fault detection module, each software module independently generates error codes and reports the error codes to an error code management module, the error code management module caches all the error codes, when the error codes are newly added or deleted, a derivation rule base is traversed, fault detection is completed from rules defined by the derivation rule base, the method changes the original complex hard coding completion fault judgment mode into a derivation according to configuration rules, a fault detection algorithm is solidified, and frequent fault judgment logic modification is avoided, and the method is easy to test, modify and upgrade and maintain.
5. A fault detection module based on derivation rules:
and when fault detection is carried out, the fault is deduced according to the error codes reported by the modules and the configured rules, and the fault reporting is finished. When the system fault detection is completed once, all derivation rules are traversed, and when the fault is derived according to each rule, all error codes and logic relations in the rule need to be traversed, and the algorithm is described as follows.
(a) Taking out 1 derivation rule from a derivation rule library management module;
(b) According to the error code in the derivation rule, inquiring the corresponding error code in the error code management module, and making decisions on different logic relations as follows:
the logical relation is that the error code management module must be able to inquire the error code and return to (a) determine the next error code of the rule; otherwise, the result of the rule can not be deduced, and the next rule is judged by returning to the step (a);
the logic relation is or, because or represents that the error code can exist or can not exist, when the judgment condition is yes, the error code is directly ignored without influencing the final derivation result, and the next error code of the rule is returned to (b) and judged;
if the logic relation is not, the error code management module can not inquire the error code, and returns to (b) to judge the next error code of the rule; otherwise, the result of the rule can not be deduced, and the next rule is judged by returning to the step (a).
In this embodiment, a system self-test method based on dynamic reconfiguration is provided, the method includes acquiring configurable data of historical system self-test, and generating a system self-test derivation rule set; converting the system state data into a plurality of target error codes, and storing the plurality of target error codes; when a system self-test command is received, traversing each system self-test derivation rule in the set of system self-test derivation rules, judging whether a plurality of target error codes stored in the current system meet the error codes and logic relations corresponding to the system self-checking derivation rule; if it is the requirements are met, outputting the fault information corresponding to the system self-checking derivation rule. The invention generates the system self-checking derivation rule set according to the historical configurable data, matches the error code corresponding to the system self-checking derivation rule set by using the collected system current state data, the system self-checking of dynamic reconstruction is realized, the portability and light weight of the system self-checking are realized, and the system self-checking efficiency is improved.
Referring to fig. 6, fig. 6 is a block diagram illustrating a self-test apparatus of a system based on dynamic reconfiguration according to an embodiment of the present invention.
As shown in fig. 6, the system self-test apparatus based on dynamic reconfiguration according to the embodiment of the present invention includes:
the generation module 10 is configured to acquire configurable data of the self-test of the historical system, and generate a derivation rule set of the self-test of the system according to the configurable data; the system self-test derivation rule set comprises a plurality of system self-test derivation rules, and each system self-test derivation rule stores a plurality of error codes and a logical relation corresponding to each error code;
the conversion module 20 is configured to, when system state data is received, convert the system state data into a plurality of target error codes, and store the plurality of target error codes;
the judging module 30 is configured to, when a system self-test instruction is received, traverse each of the system self-test derivation rules in the system self-test derivation rule set, and judge whether a plurality of target error codes stored in the current system satisfy an error code and a logical relationship corresponding to the system self-test derivation rule;
and the output module 40 is used for outputting the fault information corresponding to the system self-detection derivation rule if the fault information meets the requirement.
Other embodiments or specific implementation manners of the system self-inspection device based on dynamic reconfiguration in the present invention may refer to the above method embodiments, and are not described herein again.
In addition, an embodiment of the present invention further provides a storage medium, where a system self-test program based on dynamic reconfiguration is stored on the storage medium, and when the system self-test program based on dynamic reconfiguration is executed by a processor, the steps of the system self-test method based on dynamic reconfiguration described above are implemented. Therefore, a detailed description thereof will be omitted. In addition, the beneficial effects of the same method are not described in detail. For technical details not disclosed in embodiments of the computer-readable storage medium referred to in the present application, reference is made to the description of embodiments of the method of the present application. It is determined that, by way of example, the program instructions may be deployed to be executed on one computing device or on multiple computing devices at one site or distributed across multiple sites and interconnected by a communication network.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. The storage medium may be a magnetic disk, an optical disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), or the like.
It should be noted that the above-described embodiments of the apparatus are merely schematic, where the units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. In addition, in the drawings of the embodiment of the apparatus provided by the present invention, the connection relationship between the modules indicates that there is a communication connection therebetween, and may be specifically implemented as one or more communication buses or signal lines. One of ordinary skill in the art can understand and implement it without inventive effort.
Through the above description of the embodiments, those skilled in the art will clearly understand that the present invention may be implemented by software plus necessary general hardware, and may also be implemented by special purpose hardware including special purpose integrated circuits, special purpose CPUs, special purpose memories, special purpose components and the like. Generally, any functions performed by a computer program can be easily implemented by corresponding hardware, and, the specific hardware configuration for implementing the same function may be various, such as an analog circuit, a digital circuit, or a dedicated circuit. However, the implementation of a software program is a more preferable embodiment for the present invention. Based on such understanding, the technical solutions of the present invention may be embodied in the form of a software product, where the computer software product is stored in a readable storage medium, such as a floppy disk, a usb disk, a removable hard disk, a Read-only memory (ROM), a random-access memory (RAM), a magnetic disk or an optical disk of a computer, and includes instructions for enabling a computer device (which may be a personal computer, a server, or a network device) to execute the methods according to the embodiments of the present invention.
Claims (8)
1. A system self-checking method based on dynamic reconstruction is characterized by comprising the following steps:
acquiring configurable data of self-checking of a historical system, and generating a system self-checking derivation rule set according to the configurable data; the system self-test derivation rule set comprises a plurality of system self-test derivation rules, and each system self-test derivation rule stores a plurality of error codes and a logical relation corresponding to each error code; the expression of the system self-checking derivation rule is as follows: rule = { (errCode, con) }; wherein, errCode error code, con is defined as the logical relation of error code;
when system state data are received, converting the system state data into a plurality of target error codes, and storing the plurality of target error codes;
when a system self-check instruction is received, traversing each system self-check derivation rule in the system self-check derivation rule set, and if error codes of the system self-check derivation rules meet matching conditions, judging that a plurality of target error codes stored in a current system meet the error codes and logic relations corresponding to the system self-check derivation rules; the matching conditions are that the logic and the corresponding error codes can be matched in a plurality of target error codes, the logic non-corresponding error codes cannot be matched in the plurality of target error codes, and the logic or the corresponding error codes can be matched or cannot be matched in the plurality of target error codes;
if yes, outputting fault information corresponding to the system self-checking derivation rule;
if not, extracting the next system self-check derivation rule in the system self-check derivation rule set, and executing the step of judging whether a plurality of target error codes stored in the current system meet the error codes and the logical relation corresponding to the system self-check derivation rule until the system self-check derivation rule in the system self-check derivation rule set is traversed.
2. The system self-test method based on dynamic reconfiguration according to claim 1, characterized in that said logical relations include relational and, relational or and relational not.
3. The system self-test method based on dynamic reconfiguration according to claim 2, wherein when receiving a system self-test instruction, the step of traversing each of the system self-test derivation rules in the system self-test derivation rule set, and determining whether a plurality of target error codes stored in a current system satisfy the error codes and logical relationships corresponding to the system self-test derivation rules specifically includes:
traversing and extracting one system self-checking derivation rule in the system self-checking derivation rule set when a system self-checking instruction is received;
judging whether a target error code stored by the current system meets the error code and logic relation corresponding to the system self-checking derivation rule or not;
and if so, outputting fault information corresponding to the system self-checking derivation rule.
4. The system self-test method based on dynamic reconfiguration according to claim 1, characterized in that said system status data comprises software running status data and/or hardware running status data, and said error code comprises one or more of software module number, hardware module number, object type, object number, custom field, error prompt and error type.
5. The self-test method of system based on dynamic reconfiguration according to claim 1, and storing the target error code by adopting a data structure of a red-black tree or a Hash table.
6. A self-checking device of a system based on dynamic reconfiguration is characterized in that the self-checking device of the system based on dynamic reconfiguration includes:
the generation module is used for acquiring configurable data of the self-checking of the historical system and generating a system self-checking derivation rule set according to the configurable data; wherein the system self-test derivation rule set comprises a plurality of system self-test derivation rules, each system self-checking derivation rule stores a plurality of error codes and a logical relation corresponding to each error code; the expression of the system self-checking derivation rule is as follows: rule = { (errCode, con) }; wherein, errCode error code, con is defined as the logical relation of error code;
the conversion module is used for converting the system state data into a plurality of target error codes and storing the target error codes when the system state data is received;
the judging module is used for traversing each system self-check derivation rule in the system self-check derivation rule set when a system self-check instruction is received, and judging that a plurality of target error codes stored in the current system meet the error codes and the logic relation corresponding to the system self-check derivation rule if the error codes of the system self-check derivation rules meet the matching condition; the matching conditions are that the logic and the corresponding error codes can be matched in a plurality of target error codes, the logic non-corresponding error codes cannot be matched in the plurality of target error codes, and the logic or the corresponding error codes can be matched or cannot be matched in the plurality of target error codes;
the output module is used for outputting the fault information corresponding to the system self-checking derivation rule if the fault information meets the requirement; for extracting the next system self-check derivation rule in the system self-check derivation rule set if the rule is not satisfied, and executing the step of judging whether a plurality of target error codes stored by the current system meet the error codes and the logical relation corresponding to the system self-checking derivation rule or not until the system self-checking derivation rule in the system self-checking derivation rule set is traversed and completed.
7. A system self-test device based on dynamic reconfiguration, characterized in that the system self-test device based on dynamic reconfiguration includes: a memory, a processor and a dynamic reconfiguration based system self-test program stored on the memory and executable on the processor, the dynamic reconfiguration based system self-test program implementing the steps of the dynamic reconfiguration based system self-test method according to any one of claims 1 to 5 when executed by the processor.
8. A storage medium, wherein a system self-test program based on dynamic reconfiguration is stored on the storage medium, and when being executed by a processor, the system self-test program based on dynamic reconfiguration implements the steps of the system self-test method based on dynamic reconfiguration according to any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210274551.1A CN114676006B (en) | 2022-03-18 | 2022-03-18 | System self-checking method, device, equipment and storage medium based on dynamic reconfiguration |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210274551.1A CN114676006B (en) | 2022-03-18 | 2022-03-18 | System self-checking method, device, equipment and storage medium based on dynamic reconfiguration |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114676006A CN114676006A (en) | 2022-06-28 |
| CN114676006B true CN114676006B (en) | 2023-03-31 |
Family
ID=82073778
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210274551.1A Active CN114676006B (en) | 2022-03-18 | 2022-03-18 | System self-checking method, device, equipment and storage medium based on dynamic reconfiguration |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114676006B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116930727B (en) * | 2023-09-18 | 2023-11-28 | 北京怀美科技有限公司 | Chip detection method based on circuit board |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5546507A (en) * | 1993-08-20 | 1996-08-13 | Unisys Corporation | Apparatus and method for generating a knowledge base |
| CN109844867A (en) * | 2016-10-14 | 2019-06-04 | 3M创新有限公司 | Self-test for personal safety equipment |
| CN112085588A (en) * | 2020-09-02 | 2020-12-15 | 支付宝(杭州)信息技术有限公司 | Method and device for determining safety of rule model and data processing method |
| CN113485939A (en) * | 2021-07-27 | 2021-10-08 | 芜湖雄狮汽车科技有限公司 | Software system error code management method and device, electronic equipment and storage medium |
-
2022
- 2022-03-18 CN CN202210274551.1A patent/CN114676006B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5546507A (en) * | 1993-08-20 | 1996-08-13 | Unisys Corporation | Apparatus and method for generating a knowledge base |
| CN109844867A (en) * | 2016-10-14 | 2019-06-04 | 3M创新有限公司 | Self-test for personal safety equipment |
| CN112085588A (en) * | 2020-09-02 | 2020-12-15 | 支付宝(杭州)信息技术有限公司 | Method and device for determining safety of rule model and data processing method |
| CN113485939A (en) * | 2021-07-27 | 2021-10-08 | 芜湖雄狮汽车科技有限公司 | Software system error code management method and device, electronic equipment and storage medium |
Non-Patent Citations (1)
| Title |
|---|
| Built-In-Self-Test Methodology for Hardwares of Dynamically Reconfigurable Computer;Qizhong Zhou等;《2011 2nd Intl Conf on Innovative Computing & Communication and 2010 Asia-Pacific Conf on Information Technology & Ocean Engineering》;第234-237页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114676006A (en) | 2022-06-28 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110442329A (en) | Generation method, device, storage medium and the computer equipment of code segment | |
| US20220374238A1 (en) | Operator registration method and apparatus for deep learning framework, device and storage medium | |
| CN114676006B (en) | System self-checking method, device, equipment and storage medium based on dynamic reconfiguration | |
| CN109634644A (en) | Method and device for upgrading firmware of sensor through wireless communication | |
| CN112350872B (en) | Network architecture configuration information generation method and device, storage medium and electronic equipment | |
| CN104166704A (en) | Method and device for shielding heterogeneous data sources | |
| CN110109893A (en) | The method and apparatus of data modeling and operation | |
| CN113127357B (en) | Unit test method, apparatus, device, storage medium, and program product | |
| CN202533938U (en) | Touch query machine/mobile equipment-based land grading and evaluation processing system | |
| CN117170655A (en) | Metadata processing method and device, data processing equipment and storage medium | |
| CN113138996A (en) | Statement generation method and device | |
| CN117093628A (en) | Vector retrieval method, device, equipment and storage medium | |
| CN104615539A (en) | Measurement parameter processing method and system | |
| CN115982218A (en) | Method and device for recording inspection traces | |
| CN101426220A (en) | Method, apparatus and system for base station cutover | |
| CN105518672A (en) | Data retrieval across multiple models | |
| US11023361B1 (en) | Intelligent automated way of baselining integration content using messages from historical tests to be used for regression testing | |
| CN114708487A (en) | Logistics distribution business information analysis method and server applying big data | |
| CN208421584U (en) | A kind of injection molding acquisition terminal | |
| WO2023279752A1 (en) | Version management method and apparatus for database model, and related device | |
| CN112449354A (en) | Base station type replacement method, equipment and SDR network management system | |
| CN116126478B (en) | Method, device, equipment and medium for generating interface control document | |
| CN110175116B (en) | Test date switching method, device and system | |
| CN109002984A (en) | Management method, device, medium and the calculating equipment of digital asset | |
| CN111190802B (en) | Method for automatically generating performance test configuration |
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 |