US20130297977A1 - Thread based dynamic data collection - Google Patents

Thread based dynamic data collection Download PDF

Info

Publication number
US20130297977A1
US20130297977A1 US13873553 US201313873553A US2013297977A1 US 20130297977 A1 US20130297977 A1 US 20130297977A1 US 13873553 US13873553 US 13873553 US 201313873553 A US201313873553 A US 201313873553A US 2013297977 A1 US2013297977 A1 US 2013297977A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
data
computer
collector
exception
system
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.)
Abandoned
Application number
US13873553
Inventor
Peter R. MacFarlane
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
International Business Machines Corp
Original Assignee
International Business Machines Corp
Priority date (The priority date 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 date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00Error detection; Error correction; Monitoring
    • G06F11/07Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/0703Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
    • G06F11/0766Error or fault reporting or storing
    • G06F11/0787Storage of error reports, e.g. persistent data storage, storage using memory protection
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00Error detection; Error correction; Monitoring
    • G06F11/30Monitoring
    • G06F11/34Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3404Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment for parallel or distributed programming
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00Error detection; Error correction; Monitoring
    • G06F11/30Monitoring
    • G06F11/34Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3466Performance evaluation by tracing or monitoring
    • G06F11/3476Data logging
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F2201/00Indexing scheme relating to error detection, to error correction, and to monitoring
    • G06F2201/865Monitoring of software

Abstract

Dynamically collecting data pertaining to a program execution. Execution of the program in a plurality of threads can be monitored. Responsive to identifying an exception triggered by the program execution in a first of the plurality of threads, at least one data collector can be initiated to collect data exclusively relevant to the program execution in the first thread.

Description

    CROSS-REFERENCE TO RELATED APPLICATIONS
  • This application is a continuation of U.S. application Ser. No. 13/348,932, titled THREAD BASED DYNAMIC DATA COLLECTION, and filed Jan. 12, 2012, the entirety of which is fully incorporated herein by reference.
  • BACKGROUND
  • One or more embodiments disclosed within this specification relate to analysis of software applications.
  • When an application is executed by a processing system, data related to the application execution oftentimes is recorded into a log file as log file entries. These log file entries can indicate errors that occur during the application execution. Accordingly, the log file can be analyzed in order to determine the source of an error and a potential corrective action that may be implemented in the application to prevent future occurrences of the error.
  • BRIEF SUMMARY
  • One or more embodiments disclosed within this specification relate to dynamically collecting data pertaining to a program execution. An embodiment can include a system including a processor configured to initiate executable operations. The executable operations can include monitoring execution of the program in a plurality of threads and, responsive to identifying an exception triggered by the program execution in a first of the plurality of threads, initiating at least one data collector to collect data exclusively relevant to the program execution in the first thread.
  • Another embodiment can include can include a computer program product for dynamically collecting data pertaining to a program execution. The computer program product can include a computer-readable storage medium having computer-readable program code embodied therewith, the computer-readable program code configured to perform the various operations and/or functions disclosed within this specification.
  • BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS
  • FIG. 1 is a block diagram illustrating a system for dynamically collecting data pertaining to a program execution in accordance with one embodiment of the present invention.
  • FIG. 2 is a flowchart illustrating a method of registering a component data collector with a first failure data capture (FFDC) system in accordance with one embodiment of the present invention.
  • FIG. 3 is a flowchart illustrating a method of creating a thread based collector context in accordance with one embodiment of the present invention.
  • FIG. 4 is a flowchart illustrating a method of exception handling in accordance with one embodiment of the present invention.
  • FIG. 5 is a flowchart illustrating a method of collecting thread based data in response to an exception being triggered in accordance with one embodiment of the present invention.
  • DETAILED DESCRIPTION
  • As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer-readable medium(s) having computer-readable program code embodied, e.g., stored, thereon.
  • Any combination of one or more computer-readable medium(s) may be utilized. The computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer-readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk drive (HDD), a solid state drive (SSD), a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), a digital versatile disc (DVD), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
  • A computer-readable signal medium may include a propagated data signal with computer-readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer-readable signal medium may be any computer-readable medium that is not a computer-readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
  • Program code embodied on a computer-readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber, cable, RF, etc., or any suitable combination of the foregoing. Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java™, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer, or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
  • Aspects of the present invention are described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer, other programmable data processing apparatus, or other devices create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
  • These computer program instructions may also be stored in a computer-readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer-readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
  • The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
  • The arrangements described herein relate to dynamically collecting data pertaining to a program execution. More particularly, execution of a program in a plurality of threads is monitored. Responsive to an exception being triggered by the program execution in a first of the plurality of threads, a data collector can be initiated to collect data exclusively relevant to the program execution in the first thread. In this regard, the data collected can be thread specific. Accordingly, program activity related to a thread that encounters an exception can be analyzed, while data unrelated to that thread can be ignored, thus simplifying error analysis.
  • FIG. 1 is a block diagram illustrating a system 100 for in accordance with one embodiment of the present invention. The system 100 can include at least one processor 105 coupled to memory elements 110 through a system bus 115 or other suitable circuitry. As such, the system 100 can store computer-readable program code (hereinafter “program code”) within memory elements 110. The processor 105 can execute the program code accessed from the memory elements 110 via the system bus 115. In one aspect, for example, the system 100 can be implemented as computer that is suitable for storing and/or executing program code. It should be appreciated, however, that the system 100 can be implemented in the form of any system including a processor and memory that is capable of performing the functions and/or operations described within this specification.
  • The memory elements 110 can include one or more physical memory devices such as, for example, local memory 120 and one or more bulk storage devices 125. Local memory 120 refers to random access memory or other non-persistent memory device(s) generally used during actual execution of the program code. Bulk storage device(s) 125 can be implemented as a hard disk drive (HDD), solid state drive (SSD), or other persistent data storage device. The system 100 also can include one or more cache memories (not shown) that provide temporary storage of at least some program code in order to reduce the number of times program code must be retrieved from bulk storage device 125 during execution.
  • Input/output (I/O) devices such as a keyboard 130, a display 135, and a pointing device 140 optionally can be coupled to the system 100. The I/O devices can be coupled to the system 100 either directly or through intervening I/O controllers. One or more network adapters 145 also can be coupled to the system 100 to enable the system 100 to become coupled to other systems, computer systems, remote printers, and/or remote storage devices through intervening private or public networks. Modems, cable modems, and Ethernet cards are examples of different types of network adapters 145 that can be used with the system 100.
  • As pictured in FIG. 1, the memory elements 110 can store a computer program under test (CPUT) 150, a first failure data capture (FFDC) system 155, and a thread-specific data collection application (hereinafter “data collection application”) 160, each of which can be implemented in the form of executable program code and can be executed by the system 100. The data collection application 160 can include a data collector module 165 that creates thread based data collectors (hereinafter “data collectors”), which are configured to collect thread specific data corresponding to execution of the CPUT 150 in various respective threads. Specifically, when each instance of the CPUT 150 is executed, instances of the data collectors can be initialized. Each data collector instance can correspond to a particular class or method associated with the CPUT 150.
  • The memory elements 110 also can store a collector registry 170 and one or more thread based collector contexts (hereinafter “collector contexts”) 175. Each collector context 175 can include a collector stack 180 and an exception collector list 185. The collector stack 180 can store a reference to each instance of the data collectors that are initialized for a corresponding instance of the CPUT 150 to collect data pertaining to the execution of that instance of the CPUT 150, and store a reference to a particular class or method tracked by the data collector. The exception collector list 185 can hold references to each instance of a data collector that is initialized to collect data related to an exception caused by execution of the instance of the CPUT 150. In this regard, the data collectors referenced in the exception collector list 185 can be referred to as “exception collectors.”
  • The CPUT 150, the FFDC system 155, the thread specific data collection application 160, the collector registry 170 and the collector context 175 can be considered part of the system 100. In one embodiment, the thread specific data collection application 155, the FFDC system 160, the collector registry 170 and the collector context(s) 175 can be implemented in IBM® WebSphere® Enterprise Service Bus, though the invention is not limited in this regard (IBM and WebSphere are trademarks of International Business Machines Corporation in the United States, other countries, or both).
  • In operation, a plurality of instances of the CPUT 150 can be executed by the processor 105 in different threads. The CPUT 150 can be, for example, a web-based application, though the invention is not limited in this regard; the CPUT 150 can be any other application for which multiple instances of the application may be executed in different threads. When an exception in one of the threads occurs, the corresponding instances of the data collectors can capture data corresponding to the exception, as well as context information relating to the thread execution, and store data and context information in the memory elements 110. The data and context information can be accessed to analyze the circumstances related to cause of the exception, and whether further FFDC events should be triggered. The following flowcharts provide further details on such operations.
  • FIG. 2 is a flowchart illustrating a method 200 of registering a component data collector with a FFDC system in accordance with one embodiment of the present invention. At step 202, during startup of a processing system, such as the processing system 100 of FIG. 1, the FFDC system and the data collection application can be initialized, for example by invocation of respective initialize( )methods. At step 204, during initialization of the data collection application, the data collector can be initialized. At step 206, the data collector can be registered with the FFDC system.
  • FIG. 3 is a flowchart illustrating a method 300 of creating a thread based collector context in accordance with one embodiment of the present invention. At step 302, an instance of a CPUT being invoked can be detected. For example, a processMessage( ) method being invoked can be detected. At step 304, a CPUT entry method can notify the collector registry that a new instance of the CPUT on a thread has started, and the collector registry can create a thread based collector context for that thread. It is noted that multiple instances of the CPUT may be executing in different threads, and a collector context can be created for each instance of the CPUT.
  • At step 306, thread based data collector instances can be created by the collector registry to collect data corresponding to execution of the new instance of the CPUT in a corresponding thread. Further, the data collector instances can be registered based on classes and methods having corresponding data to collect. For example, a reference to each data collector instance can be added to the collector stack associated with the collector context created for the thread in which the particular instance of the CPUT is executing, and the class or method to which each data collector instance corresponds can be identified in the collector stack.
  • FIG. 4 is a flowchart illustrating a method 400 of exception handling in accordance with one embodiment of the present invention. At step 402, the execution of CPUT instances can be monitored in each of a plurality of threads. At step 404, an exception caused by execution of an instance of the CPUT in a thread can be detected. For example, a catch( ) method can be implemented. At step 406, the data collection application can intercept the exception and, via the data collector module and/or the collector registry, dynamically create a data collector for the exception. In illustration, the data collector for the exception can be an exception collector that the collector registry registers in the exception collector list. At step 408, the exception can be identified by a class or method that includes responsibility for reporting executions.
  • At step 410, an FFDC event can be triggered by the FFDC and processing of the FFDC event can be initiated by the FFDC system. For example, the exception caught at step 404 can be re-thrown such that hither methods/functions may themselves catch the exception and perform their own processing. Although other class/methods higher in the stack may also have responsibility for reporting the exceptions, because the FFDC already has been recorded for the particular exception, no further FFDC events need be triggered. In other words, a single instance of the FFDC need only be initiated for a particular exception that is identified. A second FFDC instance need not be initiated if it contains data contained in the first FFDC instance. This feature can be achieved using a state held in the collector context.
  • FIG. 5 is a flowchart illustrating a method 500 of collecting thread based data in response to an exception being triggered in accordance with one embodiment of the present invention. At step 502, via the FFDC system, the data collector created during the initialization of the processing system (FIG. 2, step 204) can be invoked. At step 504, via the data collector instances associated with the thread in which the exception is triggered, data relevant to the CPUT execution in the thread, such as context data, can be collected. For example, the data collection application can iterate through the data collectors, invoking each of the data collectors to perform data collection. The data relevant to the CPUT execution can include data exclusively relevant to execution of the CPUT instance. For example, at least one data collector can be invoked that collects data exclusively relevant to the CPUT execution in the thread. Since data irrelevant to the CPUT execution in the particular thread is not collected, a failure analysis process can be streamlined.
  • Initiation of the data collector by the FFDC system can occur prior to FFDC functions of the FFDC system being initiated. In other words, the FFDC system can initiate the data collectors prior to initiation of other FFDC specific functions. The data collector can be initiated to collect data for an instance of a method in a call stack nearest an exception in the call stack. The exception can be an original exception triggered by the program execution in the thread. The invention is not limited in this regard, however, and data for other instances of the method in the call stack can be collected in addition to, or in lieu of, data for the method nearest the original exception in the call stack. In another arrangement, the data collector can be initiated to collect data for an instance of a method in a call stack nearest an original execution of the program in the call stack.
  • Further, the data collector can be initiated once for a corresponding initiation of the FFDC system, and initiation of the corresponding FFDC system can be limited to a single instance of the FFDC system for the identified exception, though this need not be the case. In illustration, the occurrence of the FFDC on the thread for a particular exception can be noted for the thread based on the collector context, and this information can be used to determine that further FFDC events need not be initiated, or to determine that further FFDC events may be initiated.
  • At step 506, the collected data can be output for analysis. For example, the data can be output to a file and the file can be associated with the thread in which the exception is triggered. The data can be applied, for example, to a trace of a program execution. In another example, the data can be applied to an error analysis application, for instance to determine where to put an execution break in the CPUT to capture other data relevant to the CPUT execution.
  • At step 508, the data collector can be de-registered can de-register by removing the data collector from the exception collector list. De-registering of the data collector can occur while the CPUT continues to execute. In this regard, the method 400 of FIG. 4 can continue while the method 500 is implemented.
  • Like numbers have been used to refer to the same items throughout this specification. The flowcharts and block diagram in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagram may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagram and/or flowcharts illustrations, and combinations of blocks in the block diagram and/or flowchart illustrations, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
  • The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
  • The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the invention. The embodiment was chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.

Claims (13)

  1. 1-12. (canceled)
  2. 13. A system comprising:
    a processor configured to initiate executable operations comprising:
    monitoring execution of the program in a plurality of threads; and
    responsive to identifying an exception triggered by the program execution in a first of the plurality of threads, initiating at least one data collector to collect data exclusively relevant to the program execution in the first thread.
  3. 14. The system of claim 13, wherein the processor further is configured to register the data collector with a first failure data capture system.
  4. 15. The system of claim 13, wherein the processor initiating the data collector to collect data exclusively relevant to the program execution in the first thread occurs prior to a first failure data capture system has been initiated.
  5. 16. The system of claim 15, wherein the processor initiating the data collector to collect data exclusively relevant to the program execution in the first thread comprises the processor initiating the data collector once for a corresponding initiation of the first failure data capture system.
  6. 17. The system of claim 16, wherein the processor initiating the data collector to collect data exclusively relevant to the program execution comprises the processor limiting the initiation of the corresponding first failure data capture system to a single instance of the first failure data capture system for the identified exception.
  7. 18. The system of claim 13, wherein the processor initiating the data collector to collect data exclusively relevant to the program execution comprises the processor initiating the data collector to collect data for an instance of a method in a call stack nearest the exception in the call stack, wherein the exception is an original exception triggered by the program execution in the first of the plurality of threads.
  8. 19. A computer program product for dynamically collecting data pertaining to a program execution, the computer program product comprising:
    a computer-readable storage medium having computer-readable program code embodied therewith, the computer-readable program code comprising:
    computer-readable program code configured to monitor execution of the program in a plurality of threads; and
    computer-readable program code configured to, responsive to identifying an exception triggered by the program execution in a first of the plurality of threads, initiate at least one data collector to collect data exclusively relevant to the program execution in the first thread.
  9. 20. The computer program product of claim 19, wherein the processor further is configured to register the data collector with a first failure data capture system.
  10. 21. The computer program product of claim 19, wherein initiating the data collector to collect data exclusively relevant to the program execution in the first thread occurs prior to a first failure data capture system has been initiated.
  11. 22. The computer program product of claim 21, wherein initiating the data collector to collect data exclusively relevant to the program execution in the first thread comprises initiating the data collector once for a corresponding initiation of the first failure data capture system.
  12. 23. The computer program product of claim 22, wherein initiating the data collector to collect data exclusively relevant to the program execution comprises limiting the initiation of the corresponding first failure data capture system to a single instance of the first failure data capture system for the identified exception.
  13. 24. The computer program product of claim 19, wherein initiating the data collector to collect data exclusively relevant to the program execution comprises initiating the data collector to collect data for an instance of a method in a call stack nearest the exception in the call stack, wherein the exception is an original exception triggered by the program execution in the first of the plurality of threads.
US13873553 2012-01-12 2013-04-30 Thread based dynamic data collection Abandoned US20130297977A1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US13348932 US9916192B2 (en) 2012-01-12 2012-01-12 Thread based dynamic data collection
US13873553 US20130297977A1 (en) 2012-01-12 2013-04-30 Thread based dynamic data collection

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US13873553 US20130297977A1 (en) 2012-01-12 2013-04-30 Thread based dynamic data collection

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US13348932 Continuation US9916192B2 (en) 2012-01-12 2012-01-12 Thread based dynamic data collection

Publications (1)

Publication Number Publication Date
US20130297977A1 true true US20130297977A1 (en) 2013-11-07

Family

ID=48780853

Family Applications (3)

Application Number Title Priority Date Filing Date
US13348932 Active 2035-12-24 US9916192B2 (en) 2012-01-12 2012-01-12 Thread based dynamic data collection
US13873553 Abandoned US20130297977A1 (en) 2012-01-12 2013-04-30 Thread based dynamic data collection
US15849397 Pending US20180137002A1 (en) 2012-01-12 2017-12-20 Thread based dynamic data collection

Family Applications Before (1)

Application Number Title Priority Date Filing Date
US13348932 Active 2035-12-24 US9916192B2 (en) 2012-01-12 2012-01-12 Thread based dynamic data collection

Family Applications After (1)

Application Number Title Priority Date Filing Date
US15849397 Pending US20180137002A1 (en) 2012-01-12 2017-12-20 Thread based dynamic data collection

Country Status (2)

Country Link
US (3) US9916192B2 (en)
WO (1) WO2013104964A1 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20150121151A1 (en) * 2013-10-24 2015-04-30 Fujitsu Limited Information processing apparatus and information collection method

Citations (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5918004A (en) * 1995-06-02 1999-06-29 Rational Software Corporation Remote monitoring of computer programs
US6282701B1 (en) * 1997-07-31 2001-08-28 Mutek Solutions, Ltd. System and method for monitoring and analyzing the execution of computer programs
US20030159133A1 (en) * 2001-10-26 2003-08-21 International Business Machines Corporation Method and system for tracing and displaying execution of nested functions
US20050055602A1 (en) * 2003-09-08 2005-03-10 International Business Machines Corporation (Ibm) Autonomic recovery of PPRC errors detected by PPRC peer
US20090157359A1 (en) * 2007-12-18 2009-06-18 Anton Chernoff Mechanism for profiling program software running on a processor
US20100095101A1 (en) * 2008-10-15 2010-04-15 Stefan Georg Derdak Capturing Context Information in a Currently Occurring Event
US20130305101A1 (en) * 2012-05-14 2013-11-14 Qualcomm Incorporated Techniques for Autonomic Reverting to Behavioral Checkpoints

Family Cites Families (12)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6205491B1 (en) 1997-12-18 2001-03-20 Sun Microsystems, Inc. Method and apparatus for deferred throwing of exceptions in C++
US6772376B1 (en) 2000-11-02 2004-08-03 Dell Products L.P. System and method for reporting detected errors in a computer system
US7266733B2 (en) 2002-06-13 2007-09-04 International Business Machines Corporation Method for application event integration
US7080287B2 (en) 2002-07-11 2006-07-18 International Business Machines Corporation First failure data capture
US7840856B2 (en) 2002-11-07 2010-11-23 International Business Machines Corporation Object introspection for first failure data capture
US7308609B2 (en) 2004-04-08 2007-12-11 International Business Machines Corporation Method, data processing system, and computer program product for collecting first failure data capture information
US7343521B2 (en) 2004-05-28 2008-03-11 International Business Machines Corporation Method and apparatus to preserve trace data
US7827447B2 (en) 2007-01-05 2010-11-02 International Business Machines Corporation Sliding window mechanism for data capture and failure analysis
US20080222456A1 (en) 2007-03-05 2008-09-11 Angela Richards Jones Method and System for Implementing Dependency Aware First Failure Data Capture
US8250402B2 (en) 2008-03-24 2012-08-21 International Business Machines Corporation Method to precondition a storage controller for automated data collection based on host input
US20090271663A1 (en) 2008-04-24 2009-10-29 Vining Robert G Providing detailed program state information for error analysis
CN101719301B (en) * 2009-12-22 2012-07-25 北京北方微电子基地设备工艺研究中心有限责任公司 Alarm processing method and device

Patent Citations (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5918004A (en) * 1995-06-02 1999-06-29 Rational Software Corporation Remote monitoring of computer programs
US20020049934A1 (en) * 1995-06-02 2002-04-25 Anderson Mark D. Remote monitoring of computer programs
US20040153997A1 (en) * 1995-06-02 2004-08-05 International Business Machines Corporation Remote monitoring of computer programs
US20080147853A1 (en) * 1995-06-02 2008-06-19 Anderson Mark D Remote monitoring of computer programs
US6282701B1 (en) * 1997-07-31 2001-08-28 Mutek Solutions, Ltd. System and method for monitoring and analyzing the execution of computer programs
US20030159133A1 (en) * 2001-10-26 2003-08-21 International Business Machines Corporation Method and system for tracing and displaying execution of nested functions
US20050055602A1 (en) * 2003-09-08 2005-03-10 International Business Machines Corporation (Ibm) Autonomic recovery of PPRC errors detected by PPRC peer
US20090157359A1 (en) * 2007-12-18 2009-06-18 Anton Chernoff Mechanism for profiling program software running on a processor
US20100095101A1 (en) * 2008-10-15 2010-04-15 Stefan Georg Derdak Capturing Context Information in a Currently Occurring Event
US20130305101A1 (en) * 2012-05-14 2013-11-14 Qualcomm Incorporated Techniques for Autonomic Reverting to Behavioral Checkpoints

Non-Patent Citations (5)

* Cited by examiner, † Cited by third party
Title
Brodie "Quickly Finding Known Software Problems via Automated Symptom Matching" 9/2005, IEEE, pg. 1-10 *
OpenSTA, "OpenSTA : Creating and Editing Collectors" May 2003, OpenSTA, pg. 1-20 *
Windows, "ETW (Event Tracing For Windows)" August 2009, Microsoft, pg. 1-2 *
Windows2, ".NET Framework Versions and Dependencies" 2008, Microsoft, pg. 1-6 *
Windows3, "EventProviderTraceListener Class" 2008, Microsoft, pg. 1-6 *

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20150121151A1 (en) * 2013-10-24 2015-04-30 Fujitsu Limited Information processing apparatus and information collection method
US9710319B2 (en) * 2013-10-24 2017-07-18 Fujitsu Limited Information processing apparatus and information collection method

Also Published As

Publication number Publication date Type
US9916192B2 (en) 2018-03-13 grant
US20130185600A1 (en) 2013-07-18 application
WO2013104964A1 (en) 2013-07-18 application
US20180137002A1 (en) 2018-05-17 application

Similar Documents

Publication Publication Date Title
US8291379B2 (en) Runtime analysis of a computer program to identify improper memory accesses that cause further problems
US9015702B2 (en) Determining compatibility of an application with different versions of an operating system
US20050120273A1 (en) Automatic root cause analysis and diagnostics engine
US20060020858A1 (en) Method and system for minimizing loss in a computer application
US20130074092A1 (en) Optimized Memory Configuration Deployed on Executing Code
US8578340B1 (en) Recording and replaying computer program execution with recorded execution event breakpoints
US20100100774A1 (en) Automatic software fault diagnosis by exploiting application signatures
US20080005281A1 (en) Error capture and reporting in a distributed computing environment
US20030135720A1 (en) Method and system using hardware assistance for instruction tracing with secondary set of interruption resources
US20150052402A1 (en) Cloud Deployment Infrastructure Validation Engine
US20130024731A1 (en) Real time monitoring of computer for determining speed and energy consumption of various processes
US20120124426A1 (en) Debugging in a cluster processing network
US20090193298A1 (en) System and method of fault detection, diagnosis and prevention for complex computing systems
US20080127112A1 (en) Software tracing
US20120159449A1 (en) Call Stack Inspection For A Thread Of Execution
US20080109641A1 (en) Automatic and systematic detection of race conditions and atomicity violations
US8621282B1 (en) Crash data handling
US20080282104A1 (en) Self Healing Software
US20080104441A1 (en) Data processing system and method
US8028277B2 (en) Self-healing system and method for code optimization in a computing environment
US20140366005A1 (en) Abstract layer for automatic user interface testing
US7475386B1 (en) Mechanism for disjoint instrumentation providers in a tracing framework
US20080168472A1 (en) Recording execution information
US9003402B1 (en) Method and system for injecting function calls into a virtual machine
US20080276226A1 (en) Device, method and computer program product for evaluating a debugger script

Legal Events

Date Code Title Description
AS Assignment

Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MACFARLANE, PETER R.;REEL/FRAME:030316/0919

Effective date: 20130426