The patent's assignee is
News editors obtained the following quote from the background information supplied by the inventors: "In software systems that interact with real-world hardware components, errors are often difficult to trace to a root cause. An error encountered by software interacting with one hardware component may cause a number of subsequent follow-on errors in other components or software modules interacting with these hardware components. In a software/hardware system that is capable of recording or displaying errors, multiple errors may be generated across a variety of internal subsystems in response to a root problem with the hardware or software module that encountered a problem. Displaying these multiple related errors and associating them in a meaningful way can be a difficult problem.
"In order for an operator or service engineer to successfully diagnose and resolve the overall problem in the system, the operator needs to determine the originating root cause error and treat it. The follow-on errors that may be generated from a root cause error are generally not important when diagnosing and treating the overall problem. However, in many prior art systems, the resulting errors are displayed to the operator, regardless of whether they are a likely root cause or not, in an unarranged, undistinguished fashion alongside the original root cause error. This problem may even exist where the systems have a means for associating errors.
"There is often no simple way for the operator or engineer to distinguish which error is the root cause and which errors are follow-on errors (e.g., those that are often less important from the stand point of solving the problem--merely symptoms that result from the root cause error). The operator often needs to guess the root cause error based on other information such as error timing, experience, complex log files, or luck. This guesswork can be time-consuming and costly for the operator and/or service engineer and is often detrimental to the reliability of the hardware/software system.
"In some systems, certain errors may be considered more critical than others. For example, an error that results in a total system shutdown and significant loss of productivity may be considered more severe than a simple timing error that results in a minimal loss of productivity. However, in many prior art systems, the overall severity of the root cause error may not be known until the follow-on errors are generated and manually correlated by the operator back to the root cause error. Particularly in systems where errors of lesser initial severity can be automatically hidden from the operator, it may be difficult to determine that an error that was hidden due to low severity is actually a root cause error of significance if it is not associated with more severe follow-on errors. For example, it may not be possible for the instrument to display a particular root cause error to the operator if the system does not determine the error is severe enough. Many prior art systems typically lack knowledge about the causal connections within a group of errors and this frequently prevents the true severity of the originating error from being known.
"There is a need for a system that automatically determines the causality between a group of errors. Such a system that reliably solves this problem has previously been considered extremely difficult if not impossible. While conventional systems can easily determine causal links in some cases, other cases were considered too difficult or had no known solution. In order for error-causality systems to be useful, they must be able to determine the common causalities that occur. This may be difficult if the software in the system has not been designed with this goal in mind. In particular, establishing the causality of software thread time-out errors (e.g., a software thread timing out on a lock held by another thread that is processing a different error) has been a difficult problem in system design.
"An example of a system where this need exists can be found in U.S. Pat. No. 7,381,370, assigned to the assignee of the present application and incorporated herein by reference. In complicated instruments, such as chemical analyzers, which may include a number of precisely moving parts, a root cause error may be simple in the real world but difficult to determine in software. For example, if a servo motor has become worn or stuck, it may result in errors in other mechanical portions of the instrument that interact with the motor. There is a specific need in chemical analyzers, medical devices, or other complex software/mechanical instruments to provide software mechanisms that simplify, repair, and diagnose when errors occur in the system.
"The present invention provides software mechanisms that facilitate the association of errors to assist in the determination of root cause errors versus follow-on errors. The present invention also provides software mechanisms to facilitate simplified displaying of errors to assist operators in determining root cause errors."
As a supplement to the background information on this patent application, VerticalNews correspondents also obtained the inventor's summary information for this patent application: "Embodiments of the present invention address and overcome the above shortcomings and drawbacks by providing improved methods for identifying parent-child relationships among errors. By associating errors by a causal relationship, errors can be displayed as graphs or trees. In addition, improved methods of assigning severity levels to errors within the graph allows for simplified filtering of less severe errors, without masking likely root cause errors. This technology is particularly well-suited for, but by no means limited to, software systems for interacting with hardware systems, such as diagnostic test equipment and instrumentation.
"Embodiments of the present invention are directed to a method for reporting errors in a software environment including a first step of generating a first error by a first software thread, including a first error ID, in response to a first error condition relating to the state of at least one resource. The method further includes propagating the first error ID to at least one second software thread, generating a second error by the second software thread, including a second error ID and the first error ID, in response to a second error condition relating to the state of at least one resource, and reporting the first and second errors to a user.
"According to one aspect of the invention, the method for reporting errors further includes the step of reporting the errors to a user interface. According to another aspect of the invention the first and second IDs comprise unique identifiers. According to a further aspect of the invention, the method for reporting errors further includes propagating the first error ID to at least one third software thread, generating a third error by the third software thread, including a third error ID and at least one of the first or second error IDs, and reporting the third error to the user.
"According to one aspect of the invention, the step of propagating the first error ID includes updating an attribute in a software object that is accessible to both the first and second threads. According to another aspect of the invention, a software object includes a lock, such that only one of the first and second threads can control the resource at any given time.
"Embodiments of the present invention are directed to a method for reporting errors in a software environment, including requesting, by a first software thread, access to a shared resource guarded by a software object controlled by a second software thread. The method further includes determining whether a time-out condition has occurred while the first thread is awaiting access to the shared resource, generating an error in response to the determining step, including a first error that includes a first error ID, obtaining from the software object a second error ID associated with the second thread, and associating the first and second error IDs. The method can then report the first error along with an association between the first and second error IDs to a user.
"According to one aspect of the invention, reporting errors includes reporting the errors to a user interface. According to another aspect of the invention, the first and second IDs are unique identifiers. According to a further aspect of the invention, the method for reporting errors further includes updating information in the software object, by the second thread, to include the second error ID when the second thread encounters an error while the second thread has control over the software object.
"According to one aspect of the invention, the software object is a lock, such that only one of the first and second threads can control the hardware resource at any given time. According to another aspect of the invention, the software object is an object that propagates a signal from the first thread to the second thread upon completion of an instruction sequence by the first thread. According to an additional aspect of the invention, the shared resource is a shared hardware and/or shared software resource.
"Embodiments of the present invention are directed to a method for displaying errors to a user, including gathering a plurality of errors representing hardware or software error conditions. The method further includes associating the plurality of errors into a graph to convey causal relationships amongst the errors, including at least one parent error and one or more child errors and displaying the graph of errors to a user. Causal relationships can be determined based on identifiers within the errors.
"According to one aspect of the invention, each error has a predetermined severity. According to another aspect of the invention, the method for displaying errors to a user further includes determining a severity of each of the plurality of errors and displaying those errors that have a severity above a threshold. According to a further aspect of the invention, at least one parent error is displayed where at least one of the one or more child errors exceeds the threshold. According to yet another aspect of the invention, a parent error can be assigned the highest level of severity determined for the one or more child errors. According to a further aspect of the invention, one or more child errors are masked when an assigned severity of a parent exceeds an assigned priority of the child error.
"Additional features and advantages of the invention will be made apparent from the following detailed description of illustrative embodiments that proceeds with reference to the accompanying drawings.
BRIEF DESCRIPTION OF THE DRAWINGS
"The foregoing and other aspects of the present invention are best understood from the following detailed description when read in connection with the accompanying drawings. For the purpose of illustrating the invention, there is shown in the drawings embodiments that are presently preferred, it being understood, however, that the invention is not limited to the specific instrumentalities disclosed. Included in the drawings are the following Figures:
"FIG. 1A is a dataflow diagram illustrating generation of exemplary errors;
"FIG. 1B is a data diagram of an exemplary error;
"FIG. 1C is a graph illustrating the relationship between related errors;
"FIG. 2A is a dataflow diagram illustrating generation of exemplary errors;
"FIG. 2B is a graph illustrating the relationship between related errors;
"FIG. 3A is a timing diagram illustrating the competition between threads for a shared lockable resource;
"FIG. 3B is a timing diagram illustrating the competition between threads for a shared lockable resource resulting in generation of exemplary errors;
"FIGS. 4A-4E are flow charts illustrating algorithms for executing functions and generating errors in accordance with illustrative embodiments;
"FIGS. 5A-5B are exemplary screen shots for displaying error information in accordance with illustrative embodiments;
"FIGS. 6A-6B are exemplary screen shots for displaying error information in accordance with illustrative embodiments;
"FIGS. 7A-7D are exemplary tree graphs illustrating the relationships between exemplary errors in accordance with illustrative embodiments;
"FIG. 8 is a flow chart illustrating an algorithm for executing propagating severity of errors in accordance with illustrative embodiments; and
"FIG. 9 is a top view of an exemplary chemical analyzer system that could employ the methods described in the embodiments described herein."
For additional information on this patent application, see: Haines,
Keywords for this news article include: Software,
Our reports deliver fact-based news of research and discoveries from around the world. Copyright 2014, NewsRx LLC
Most Popular Stories
- Obama Administration Releases Proposal to Regulate For-Profit Colleges
- Koch Brothers Step up Anti-Obamacare Campaign
- Elizabeth Vargas' Husband Marc Cohn Addresses Rumors
- Keurig Adds Peet's coffee, Alters Starbucks deal
- Quiznos Files for Chapter 11
- U.S. to Relinquish Gov't Control Over Internet
- SoCalGas Reaches Record Spend on Diversity Suppliers
- Vybz Kartel Convicted of Murder
- FDIC Sues Big Banks Over Rate Manipulation
- U.S. Consumer Sentiment Falls in Early March