Dynamic data store for failed jobs in a systems complex

In one embodiment, a computer program product for first time data capture includes a computer readable storage medium having computer readable program code embodied therewith. The computer readable program code is configured to run jobs on a systems complex (sysplex), to trace the jobs running on the sysplex, to monitor each of the jobs running on the sysplex for an unexpected action by any of the jobs, and to store information relating to each unexpected action performed by any of the jobs into an entry of a data store. In another embodiment, a method includes running jobs on a sysplex, tracing the jobs running on the sysplex, monitoring each of the jobs running on the sysplex for an unexpected action by any of the jobs, and storing information relating to each unexpected action performed by any of the jobs into an entry of a data store.

BACKGROUND

Many large scale systems run multiple workloads over the course of any given day. These systems may be referred to as a systems complex (sysplex), which may include multiple systems, each of the multiple systems having its own complexities and infrastructure. These workloads typically run many jobs which may end abnormally due to any number of varied and often uncontrollable ways. It is an arduous job to collate all the jobs that failed across a systems complex (sysplex). There are some methods which are currently used to gather all the jobs that failed across a sysplex, but there are drawbacks to these methods, including the length of time needed to execute these methods.

Therefore, what is needed is a method in which the jobs that failed across a sysplex can be aggregated more efficiently than current methods allow.

BRIEF SUMMARY

In one embodiment, a computer program product for first time data capture includes a computer readable storage medium having computer readable program code embodied therewith. The computer readable program code includes computer readable program code configured to run one or more jobs on a systems complex (sysplex), to trace the one or more jobs running on the sysplex, to monitor each of the one or more jobs running on the sysplex for an unexpected action by any of the jobs, and to store information relating to each unexpected action performed by any of the jobs into an entry of a data store.

In another embodiment, a method includes running one or more jobs on a systems complex (sysplex), tracing the one or more jobs running on the sysplex, monitoring each of the one or more jobs running on the sysplex for an unexpected action by any of the jobs, and storing information relating to each unexpected action performed by any of the jobs into an entry of a data store.

DETAILED DESCRIPTION

The following description discloses collating failed jobs in a real-time systems complex (sysplex). According to one embodiment, an address space of a module running on a sysplex may be used to store a jobs relevant logical stack trace and to collate the jobs into a dynamic data store. The dynamic data store may be a database, a table, a list, a linked array, etc., and may be stored in the sysplex.

In one general embodiment, a computer program product for first time data capture includes a computer readable storage medium having computer readable program code embodied therewith. The computer readable program code includes computer readable program code configured to run one or more jobs on a sysplex, to trace the one or more jobs running on the sysplex, to monitor each of the one or more jobs running on the sysplex for an unexpected action by any of the jobs, and to store information relating to each unexpected action performed by any of the jobs into an entry of a data store.

In another general embodiment, a method includes running one or more jobs on a sysplex, tracing the one or more jobs running on the sysplex, monitoring each of the one or more jobs running on the sysplex for an unexpected action by any of the jobs, and storing information relating to each unexpected action performed by any of the jobs into an entry of a data store.

According to one embodiment, an address space of a module running on a system may be used to store a jobs relevant logical stack trace and to collate the jobs into a dynamic data store. The data store may be a table, a list, an array, a linked array, a database, or any other data store as would be understood by one of skill upon reading the present descriptions. For the sake of simplicity, the data store will be referred to as table for the remainder of the descriptions herein.

The table may be used for later processing of the failed jobs, in some approaches. The table may be stored in a nonvolatile memory of the system, or in some other memory, as would be known to one of skill in the art. The table may be retrieved at any time by the system, by a user, by an administrator, etc. Parsing the dynamic table is possible and may be advantageous because it allows the output and dump of the job to be stored in the table and the table may include all relevant information, such as the system the job was running on when it failed, the timestamp of the failure, etc. Certain key areas may be focused on and aggregated, especially in the case of abnormal program ends (ABENDs). There are many advantages to using the methods, systems, and computer program products described herein, including the ease of use, the ability to run completely internally all functionality without the need for any user input, a trace of job flow along with ABEND, which sysplex and/or workload is more problematic, etc.

In one approach, a dynamic table is used to store information regarding failed jobs. Inputting the jobs that failed into the table on the system in a dynamic fashion along with relevant information may allow for easy dispatch and integration into a database or front-end for the system administrator to use, such as for troubleshooting, optimization, etc.

Now referring toFIG. 3, a method300is shown according to one embodiment. The method300may be carried out in any desired environment, including those described inFIGS. 1-2, among others. Of course, more or less operations than those described below may comprise the method300, according to various embodiments.

In operation302, one or more jobs is run or executed on a systems complex (sysplex). The sysplex may be of any type known in the art, according to various embodiments. In some approaches, the jobs may include one or more tasks that the job is attempting to execute.

In operation304, the one or more jobs running on the sysplex are traced, wherein an address space of the one or more jobs running on the sysplex is used to store a logical stack trace of the one or more jobs running on the sysplex. The tracing may be accomplished using hooks in the program using branch tracing along with a central program with dynamically allocated pointers that hold the jobs running on the system, in one approach.

In one approach, the tracing may include tracing one or more code_access events for each job running on the sysplex, and tracing one or more code_branch events for each job running on the sysplex.

In another approach, the tracing may include a logical tracing algorithm. In specific approaches, the logical tracing algorithm may be stored in an operating system of the sysplex.

In operation306, each of the one or more jobs running on the sysplex is monitored for an unexpected action by any of the jobs. One such unexpected action is an abnormal job end (ABEND), according to one embodiment. Of course, other program failures may occur other than an ABEND which would also draw attention from the tracing routine, according to some approaches.

In some examples, a program that is running may be part of a larger grouping of applications or programs which comes to an end, and the program or the group of programs may perform some error routines to attempt some form of diagnostics. However, in most cases, the program would need to be restarted if it failed, or some task that the program is performing may need to be restarted. However, in some cases, the program may continue to function, albeit in some reduced fashion, and the table may still be used to log information related to the suspect program. In some embodiments, automated corrective action may be taken within the program, and in alternative embodiments, human intervention to take corrective action may be used, and in even more embodiments, both may take place. These corrective actions may be in addition to the use of the table for information logging purposes, in some approaches. In short, if a program fails or a task the program was trying to perform fails, the methods, systems, and/or computer program products described herein may be used to log information into a table for future purposes.

In operation308, information relating to each unexpected action performed by any of the jobs is stored into an entry of a data store, wherein the information comprises the logical stack of the one or more jobs running on the sysplex. In some embodiments, only relevant information is stored. Relevant information may include any information associated with the failed job that may be used to diagnose what caused the job to fail. For example, relevant information about the failed job may include each of any other interactions that were ongoing at the time that the job failed (since sometimes one of the other jobs or other pieces of storage information that is being accessed may have actually been the cause of the failure). Knowing which interactions were ongoing allows a broader picture of the system to be formed, and in many cases, when a job ABENDs, it may have actually ABENDed due to another job or interaction that occurred in some other processing in the sysplex.

The data store may be of any type, such as a table, an array, a list, a database, etc., or any other data store as would be known by one of skill in the art.

In one embodiment, the data store (table) may include job_termination_status information for each entry. In another embodiment, the data store (table) may include trace_data information for each entry, the trace_data information comprising at least one code_access event and at least one code_branch event, in one approach.

In some embodiments, the method300may include creating the data store (table) having one or more entries in response to the unexpected action and/or storing the data store (table).

The table may be stored when the job ABENDs or when some other trigger occurs, as would be understood by one of skill in the art upon reading the present descriptions. In some embodiments, a user may enter one or more triggers as a critical detection threshold which triggers storing of the failed job and other relevant information.

For example, all the jobs that failed, e.g., during a certain time period, during execution of a process, while the table is active, etc., are going to be stored into the table. Tracing algorithms as known in the art may be used to trace through the executing code and then when an ABEND occurs, the logical trace is stored into the table. Therefore, the table includes failed jobs and the traces resulting from the failed jobs being traced.

According to one embodiment, the dynamic table may be stored internally on the system, and may store relevant information to the job using tracing and taking snapshots of when the program branches into control sections (CSECTs). The table may be indexed using unique keys and may store the jobs according to job name and system information along with a timestamp.

In another embodiment, the method300may include sending the data store (table) to a system administrator for diagnosing a problem with the sysplex, or to any other entity as would be understood by one of skill in the art upon reading the present descriptions.

The table may be logged for future purposes, in one approach. This provides a quick and easy way to handle, search, diagnose, and correct failed jobs.

In one such embodiment, a computer program product for first time data capture includes a computer readable storage medium having computer readable program code embodied therewith. The computer readable program code comprises computer readable program code configured to run one or more jobs on a sysplex, computer readable program code configured to trace the one or more jobs running on the sysplex, wherein an address space of the one or more jobs running on the sysplex is used to store a logical stack trace of the one or more jobs running on the sysplex, computer readable program code configured to monitor each of the one or more jobs running on the sysplex for an unexpected action by any of the jobs, and computer readable program code configured to store information relating to each unexpected action performed by any of the jobs into an entry of a data store, wherein the information comprises the logical stack of the one or more jobs running on the sysplex.

Of course, any of the embodiments and/or approaches previously described relating to the method300may apply to the computer program product, according to various embodiments.