Event handling in a high level programming language environment

Abstract

A method and means for handling events in a computer system which occur during the execution of programs including routines prepared in a plurality of computer programming languages is described. The number and identity of each unique computer programming language used in the preparation of the program is determined using a language list contained in the application program. A unique event handling means (event handler) is initialized for each unique computer programming language used in the program. As the program executes selected events of interest to the event handlers are detected. The parameters associated with the selected event are determined. Optionally the detected events may be divided into two types: broadcast or targeted. Broadcast events are sent to all event handlers (except the debug event handler), whereas, the targeted events are sent to a single event handler. An event code and the relevant parameters are passed to the event handlers so that each event handler may perform whatever actions are appropriate for that event in the context of the programming language being supported. The event handlers generate an appropriate return code indicating the success, failure, or non-processing of the event and, for selected events, return request information. The invention provides for a separate specialized debug event handler.

Claims

What is claimed is:

1. A computer implemented method for managing event handling for processing events in a computer system, the events having associated parameters and occurring during the execution of a program, the program including routines prepared in a plurality of computer programming languages, the computer system having a common execution environment including an event handling unit and an Event Handler Interface Unit, comprising the steps of:

(a) determining, in a language list processor portion of the event handling unit, which of a plurality of computer programming languages are used in the program from high level language member identifiers for the program;

(b) initializing, in an event handler initializer portion of the event handling unit, based on the step of determining, a plurality of event handling means (event handlers) such that an event handler compatible with each computer programming language used in the program is initialized;

(c) detecting, in an event detector portion of the event handling unit, an occurrence of a selected event during execution of the program;

(d) determining, in the event handler interface unit, the computer programming language used in a currently executing routine and the associated parameters for the selected event;

(e) invoking, using the event handler interface unit, the initialized event handler compatible with the computer programming language used in the currently executing routine and passing an identifying event code and the associated parameters to said initialized event handler to cause the event to be handled, wherein the common execution environment is a single-run time environment; and

(f) repeating steps (c)-(e) each time a selected event occurs.

2. The method of claim 1, further comprising the steps of:

determining, in the event handler interface unit, whether the selected event is of a broadcast type which must be sent to all initialized event handlers; and

invoking in turn, using the event handler interface unit, for each broadcast type event, each initialized event handler not previously invoked by passing an identifying event code and the associated parameters to each initialized event handler for processing.

3. The method of claim 1, wherein the step of determining said plurality of computer programming languages used in said program further comprises determining said plurality of computer programming languages from high level language member identifiers contained in at least one program prologue area.

4. The method of claim 1, wherein said initializing step further comprises the steps of:

building an assigned name for each event handler using the high level language member identifiers; and

loading, from memory into the computer system each event handler using the assigned name.

5. The method of claim 1, further comprising the step of receiving, using the event handler interface unit, a return code from the event handler, the return code having a value indicative of success, non-processing or failure of processing of the event.

6. The method of claim 1, further comprising the step of receiving, using the event handler interface unit, return information from the event handler, said return information indicative of DSA Ownership, Entry Point and Compile Unit Identification, Statement Identification, or DSA Classification.

7. The method of claim 1, further comprising the step of initializing, using the event handling unit, a debug event handler.

8. The method of claim 7 wherein the system is capable of detecting error conditions, and the step of initializing the debug event handler is responsive to an initial command string, an error condition, or an express request from the program.

9. A computer implemented method for handling events for a computer programming language in a computer system having a processor, a common execution environment (CEE) having an event handling unit and an event handler interface unit, and an event handler, comprising the steps of:

(a) receiving, in the Event Handler Interface Unit, an Event Code and parameters corresponding to an event from the CEE;

(b) determining, in the event handler interface unit, whether the Event Code requires any information, including stack frame ownership information, entry point information, compile unit identification information, or a statement number which corresponds to an address from the event handler, responsive thereto finding the required information; and

(c) returning to the CEE any information found in step (b), wherein the CEE is a single-run time environment.

10. A computer system for handling events occurring during the execution of a program, the program including routines prepared in a plurality of computer programming languages, comprising:

means for determining which of a plurality of computer programming languages are used in the program from high level language member identifiers for the program;

means for initializing an event handling means (event handler) compatible with each computer programming language;

means for detecting an occurrence of a selected event during execution of the program;

means for determining the computer programming language used in a currently executing routine and parameters associated with the selected event; and

means for invoking an event handler compatible with the computer programming language used in the currently executing routine and passing an identifying event code and the associated parameters to the event handler to cause the event to be handled, wherein said identifying event code and said associated parameters are passed to the event handler through a common execution environment, and wherein said common execution environment is a single-run time environment.

11. The system of claim 10 further comprising:

means for determining whether the selected event is of a broadcast type which must be sent to all initialized event handlers; and

means for passing, for all broadcast type events, an identifying event code and the associated parameters to all initialized event handlers.

12. The system of claim 10 further comprising means for determining an event handler to which to pass the event code and the parameters using high level language member identifiers taken from a program prologue area.

13. The system of claim 10 wherein the means for initializing further comprises:

means for building a name for each event handler by using a preassigned member identifier; and

means for requesting dynamic loading of each event handler using the name.

14. The system of claim 10, further comprising means for receiving a return code from the event handler, the return code having a value indicative of success, non-processing or failure of processing of the event.

15. The system of claim 10 further comprising means for receiving return information from the event handler indicating DSA Ownership, Entry Point and Compile Unit Identification, Statement Identification, or DSA Classification.

16. The system of claim 10 further comprising means for initializing a debug event handler.

17. The system of claim 16 wherein the means for initializing the debug event handler is responsive to an initial command string, an error condition, or an express request from the program.

Description

TECHNICAL FIELD

The present invention relates to method systems in the field of program execution management in computer system.

BACKGROUND OF THE INVENTION

The various High Level Languages (HLLs) for computer programming (e.g., (C, COBOL, FORTRAN, PL/I, etc.) have differing run-time event handling requirements. Events which may be defined in one language may not be defined in another.

Execution of programs written in typical programming languages normally requires that language specific run-time support code be present and initialized to enable the code produced by the respective compilers to function correctly. The run-time support will typically include various functions that are required by many if not all programs written in that language. Routines to perform input/output operations would be one example.

It is possible and often desirable to build programs from routines written in several languages. The run-time support should therefore, be able to simultaneously satisfy the requirements of an arbitrary number of languages with differing requirements. It is possible to isolate common routines which appear in many run-time support packages and place them into a common run-time support package which supports multi-language application programs and thereby reduce the size of the language specific support components and reduce redundancy.

A common execution environment establishes a virtual machine interface that the HLLs (which will be called "members") can exercise to manage various resources. Within such a virtual machine, various significant events can occur which mandate actions to be taken by the members which may include "ignore the event." A uniform method for notifying the members of the occurrence of such significant events within the virtual machine and allowing the members to take the appropriate actions is needed. In addition, the virtual machine needs a consistent way to obtain information from the members at discrete points in time, as request the members to perform various activities.

In the prior art intimate knowledge or the disparate specific interface between the base run-time and the HLL-specific components is required (or event handling. What is needed and not provided by the prior art is a method and means for managing event handling during program execution that allows disparate High Level Language routines to interoperate in a single run-time environment.

SUMMARY OF THE INVENTION

The present invention describes a method and means for handling events in a computer system which occur during the execution of programs including routines prepared in a plurality of computer programming languages. The number and identity of each unique computer programming language used in the preparation of the program is determined using a language list or other equivalent means and a unique event handling means (event handler) is initialized for each unique computer programming language. As the program executes selected events of interest to the event handlers are detected. The parameters associated with the selected event are determined. Optionally the detected events may be divided into two types: broadcast or targeted. Broadcast events are sent to all event handlers (which may or may not include the debug event handler), whereas, the targeted events are sent to a single event handler. An event code and the relevant parameters are passed to the event handlers so that each event handler may perform whatever actions are appropriate for that event in the context of the programming language being supported. The event handlers generate an appropriate return code indicating the success, failure, or non-processing of the event and, for selected events, return requested information. The invention provides for a separate specializied debug event handler.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram showing the relationship between an application program, the event handling unit of the Common Execution Environment (CEE) and the Event Handlers according to the invention.

FIG. 2 is a block diagram of the major components of the event handling unit of the CEE according to the invention.

FIG. 3 is a diagram of the major steps executed by the event handling unit according to the invention.

FIG. 4 is a diagram of the major steps in the operation of an event handler according to the invention.

FIG. 5 is a sample of assembler language source code used to create language list as used according to the invention.

DETAILED DESCRIPTION OF THE INVENTION

The following terms are used in this specification:

CAA

The Common Anchor Area (CAA) is a control block which represents the current state of the execution thread of the application.

CIB

Condition Information Block which contains information about the last condition, i.e., error, exception, etc. that was processed.

Condition

The terms condition and exception are often used interchangeably. These conditions or exceptions may be errors such as using an invalid machine address or attempting to divide by zero. Conditions also include events which may not be actual errors, but which require special attention.

Condition Manager

Is any program or means which gains control of the computer system when a condition occurs and which manages the handling of that condition by executing various system and/or user application routines. It may be part of the operating system, run-time environment or an application program.

DSA

Dynamic Save Area, i.e., a stack frame.

EDB

The Enclave Data Block (EDB) is a control block which represents the current state of the enclave and represents the resources held by the enclave.

Enclave

An enclave is a logical run-time structure that supports the execution of a group of procedures. The first procedure to be invoked within the enclave is known as the "main" procedure; the others are "sub-" procedures. The enclave limits the scope of high level language semantics, including shared storage, and termination. An enclave comprises one or more threads.

Feedback Code

A leedback code is the encapsulation of a condition or error.

Heap Storage

An unordered group of occurrences or program storage areas that may be associated with programs running with a process. That is, the program storage areas of a particular type can be viewed as a heap where there is no logical ordering of the acquisition and disposal of occurrences, and where the occurrence of a program storage area in the heap is unspecified.

Invocation

An invocation is an execution instance of a code "procedure" that has received control by a logical call/return mechanism.

OCB

The Options Control Block (OCB) is a control block which contains the current settings of the run-time options.

PCB

The Process Control Block (PCB) is a control block which represents the current state of the process and represents the resources held at the process level.

Platform

Is the combination of an operating system and computer hardware on which programs may execute.

Procedure

A compilation unit that corresponds to the smallest source sequence that can be separately compiled without changing semantics.

Process

A process is the outermost run-time structure whose characteristics are described by the run-time environment. There is no hierarchical relationship among processes. Rather, each process independently and asynchronously competes for some system resources, while owning others, notably a logically separate "address space." A process comprises one or more enclaves.

PPA

Program Prologue Area which is generated by standard compilers and contains information about the compiled unit.

Stack frame

A stack frame is one element of a stack. A stack frame is created each time that a procedure is called and delete deleted when the procedure returns for the call. It is used to manage resources associated with the procedure invocation execution and return.

Stack Frame Zero

Is the conceptual stack frame immediately prior to the stack flames for the first routine. It is the theoretical place where the thread or task is initialized, the first procedure is called from and termination is initiated from, for the purpose of condition handling, the zero-th stack frame is the frame at which the default actions for a language are applied.

Static storage

A program's working storage that gets a new allocation the first time the program is run within an enclave and is not automatically deallocated when the program returns. Static storage is persistent across multiple runs of the program within an enclave.

Thread

A thread is the basic unit of execution within the run-time environment program model. The resources that it owns are a machine state, a stack and a a logically distinct condition manager. Each thread competes asynchronously for execution.

The invention is implemented in the interfaces between the unique run-time event handling modules associated with the various high level language compilers and the Event Handling Unit (EHU) of a common execution environment (CEE). FIG. 1 shows the block components in a system based on the invention. The Event Handling Unit of CEE 11 interfaces between the application program 12 and the event handlers 13-15. The CEE and the event handlers run in the problem state as a program separate from the operating system, but they can easily be included as part of the operating system without essential modification being required. The application program (which will usually be simply called the program) contains a language list 16 which identifies all of the HLLs used in the preparation of the program's various components. Each routine (compilation unit) 17-18 should contain an indication of the language in which it was written. This is preferably done by placing an assigned member number in the Program Prologue Area (PPA).

FIG. 2 shows the major components of the EHU. The Language List Processor 21 is responsible for finding and interpreting the contents of the language list inside the application program. The output is a list of members which is then used by the Event Handler Initializer 22 to load the needed Event Handlers from the load library. The Event Handler Initializer allows the Event Detector 23 to become active after initialization has completed. When the occurrence of any relevant event is detected by the Event Detector then the Event Handler Interface Unit 24 gathers the needed parameters and passes them along with an event code which idenitifies the type of event to one or more Event Handles. The Event Handler Interface Unit also receives the return code and any return information supplied by the Event Handler. The detection of the events can be performed by well known prior art means. Typically the events may be explicit in the actions of the program. For example, when the program terminates it will explicitly notify CEE, which will then cause the appropriate event handlers to be driven. Implicit events may be associated with errors or other conditions which occur during the execution of the program.

When a defined event occurs the CEE must make a number of determined in order to properly route it to the correct Event Handler(s). The basic type of the event will determine what parameters, if any, should be passed to the Event Handler and whether the event is potentially of interest to all of the Event Handlers or whether only a single Event Handler should be invoked. If the event is determined to be of interest only to the Event Handler which corresponds to the currently executing routine, then the identity of that Event Handler is ascertained by examining the current routine's PPA which should contain the member code. This type of event will he said to be `targeted` to one Event Handler. Events which will be passed sequentially to all Event Handlers will be said to be `broadcast`. The specific embodiment of the invention will determine which events need to be broadcast and which do not. Each Event Handler has the option of taking no action when invoked for a particular event. If the PPA does not contain a member code, then an event which might be otherwise targeted can be broadcast until the owner of the event is found.

FIG. 3 shows the major steps executed by the EHU according to the invention. The identity of the languages used in the program are determined from the language list contained in the program 31, then the Event Handler is initialized for each language 32. When a relevant event is detected 33, the associated parameters are determined 34. The decision is made as to whether to broadcast the event 35, and if so, the event code and parameters are passed to each Event Handler. Each Event Handler must at least return a return code which is then processed appropriately 36. For non-broadcast events the identity of the correct Event Handler is determined from the member number which is, contained in the PPA of the currently executing routine 37. An event code and parameters 38 are passed to the identified Event Handler and the return information is processed after the Event Handler completes 39.

The invention separates the generalized execution environment and the unique requirements of individual HLLs and debuggers through the Event Handler and the Debugger Event Handler respectively. The interfaces provided by the event handlers allow additional languages and debuggers to run in CEE without requiring CEE to have intimate knowledge of any particular HLL or debugger.

The invention operates by:

providing a mechanism to positively identify the presence of a member within the virtual machine

establishing a means of communication from the virtual machine to the members within the virtual machine, notifying the member of significant events

defining an interface for the communication of such events and the responses from the members

providing a framework within which the member can carry out its desired actions for the significant events that occur

providing a mechanism that will provide information from the members to the virtual machine.

In order to properly interface with CEE as a participating HLL member, the member must provide an Event Handler in the form of a loadable module. CEE requests that the Event Handler be loaded using standard operating system functions and the starting address of the executable code is returned to CEE by the operating system. This provides the mechanism by which CEE communicates the occurrence of various significant events and by which CEE receives information from the members. The number of unique members is arbitrarily limited to 256 in the preferred embodiment because only one byte is used for the member code.

FIG. 4 shows an overview or the actions which need to be taken by an Event Handler when invoked by CEE. The Event Code and parameters must be received from the Interface Unit 41. The initial determination is made as to whether the event requires any action at all by this particular Event Handler. A return code of -4 is used when no action is taken. Since some events require return information to be supplied to CEE, these events must be handled separately 45. The remaining events will be processed according to prior art techniques as is appropriate for the particular language 46. A success or failure return code is returned to CEE along with any requested information, if any, 47.

An interactive debugger is usually interested in a set of events that is usually distinct from the set of events in which members are interested. This communication of significant events is provided via a distinct event handler known as a Debugger Event Handler. In particular, a Debugger Event Handler must be provided by a participating debugger. There may be many participating debuggers available, but only one of the available debuggers, with its associated Debugger Event Handler may be used with any specific execution of a program.

Language List

CEE determines which members are present during environment initialization by examining the language list contained in the program. This is accomplished through the following steps:

1. Each member must provide a "signature CSECT" that has a fixed-format name.

2. A vector of weak external references for a set of member signature CSECT names is established.

3. If a member is present in the application (i.e., load module), the standard link edit process will place the address for that member's signature CSECT in the assigned slot in the language list. If the member is not present in the program, the index for that member's signature CSECT will contain a zero value. When a member's presence is detected, the member's Event Handler is dynamically loaded into virtual memory by CEE. A sample CSECT for a language list containing a list of weak externals is found in FIG. 5.

The Event Handler

The Event Handler is a member-supplied routine that is invoked, at various times throughoout the execution of a program when a significant event has occurred, or when CEE needs some information that is held by the member. The Event Handler contains the intimate knowledge of the requirements of the member language, but CEE is isolated from the need to know about this type of detail through the use of the invention.

During CEE initialization, the CEE will determine the set of members present in the application. For those members present, CEE will load the Event Handler. The name of the Event Handler is arbitrarily manufactured by concatenating a fixed prefix and the member number. The name constructed is "CEEEVxxx," where xxx is the member number. This name is then used to load the module containing the event handler through standard operating system calls. The address of the Event Handler is saved for later retrieval. The member number is arbitrary, but in the preferred embodiment it corresponds to the slot in the language list for the member.

Using IBM Systems 370 linkage conventions, linkage to the member event handler is via "BALR 14,15" and R1 contains a standard parameter address list. The first parameter always indicates the type of event for which the Event Handler has been called. Additional parameters are dependent upon the special event.

While processing various dump services, the Event Handler is invoked with the dump event code, 7. The dump event code has a function code parameter that describes which dump service is to be performed. The remaining parameters for the dump event vary according to the specific function code.

The Language Utilities event, 6, has a function code parameter that describes what information is being requested. The remaining parameters for the utilities event vary according to the specific function code.

The list of events and their corresponding parameters is presented in Table 1. CEEINT is a symbolic label for a callable entry point in CEE which initializes CEE. CEESTART is a symbolic label which is used to uniquely identify a load module and to navigate the load module for information such as the language list.

                                      TABLE 1
    __________________________________________________________________________
    Event Codes and Parameters
    Event   Code
               Parm 2
                    Parm 3
                         Parm 4  Parm 5
                                      Parm 6
                                           Broadcast
    __________________________________________________________________________
    Condition
            1  CIB  results
                         new condition     No
    Processing
    Enablement
            2  CIB  results
                         new condition     No
    processing           dition
    SF 0    3  CIB  results
                         new condition
                                 0         No
    Cond Processing      con-
    Option  4  Options
                    address
                         INPL    512       No
    Proc       Block
                    of cees-     work
                    tart
    Main-   5  INPL R13  R0      R1   main-
                                           No
    opts            inbound to
                         inbound to
                                 inbound to
                                      opts
                    CEEINT
                         CEEINT  CEEINT
    Process 17                             Yes
    Init
    Language
            6  functin                     No
    Utilities  code
    Dump    7  function                    Yes
    Services   code
    GOTO    10 target                      No
    Target     DSA
    DSA
    DSA Exit
            11 dsa of                      No
    routine    term block
    Enclave 18 program
                    INPL member            Yes
    Create     mask      specific
               returned  thread
    Enclave 19 INPL                        Yes
    Termination
    Process 21                             Yes
    Termination
    Debugger
            16                             No
    Info
    ATTERM  15                             No
    event
    New Load
            8  load CEES-                  No
    Load       module
                    TART or
    module     ule  or
    event      entry
                    0
               point
    __________________________________________________________________________

    ______________________________________
    Parameter Format by Function Code
    ______________________________________
    PROCEDURE (7, 1, fc)
    PROCEDURE (7, 2, dsaptr, cibptr, caaptr, edbptr, fc)
    PROCEDURE (7, 3, dsaptr, cibptr, caaptr, edbptr, fc)
    PROCEDURE (7, 4, dsaptr, cibptr, caaptr, edbptr, fc)
    PROCEDURE (7, 5, dsaptr, cibptr, caaptr, edbptr, fc)
    PROCEDURE (7, 6, caaptr, edbptr, fc)
    PROCEDURE (7, 7, caaptr, edbptr, fc)
    PROCEDURE (7, 8, edbptr, fc)
    PROCEDURE (7, 9, edbptr, fc)
    PROCEDURE (7, 10, edbptr, fc)
    PROCEDURE (7, 11, edbptr, fc)
    PROCEDURE (7, 12, edbprt, fc)
    PROCEDURE (7, 13, pcbptr, fc)
    PROCEDURE (7, 14, pcbptr, fc)
    PROCEDURE (7, 15, edbptr, fc)
    PROCEDURE (7, 16, edbptr, fc)
    PROCEDURE (7, 17, fc)
    ______________________________________

                  TABLE 2
    ______________________________________
    Debugger/CEE event handler interface
    Debugger  Debugger
    Event     Event Code
                        parm 2    parm 3   parm 4
    ______________________________________
    condition 101       CIB       result code
    raised
    goto      111       dsa
    enclave init
              118       creator's edb
    enclave term
              119
    debugger term
              121
    thread init
              120       creator's caa
    thread term
              122
    external entry
              123       + +dsa    cmd string
                                           INPL
    module load
              124       dsa       module
                                  descriptor
    module delete
              125       dsa       module name
    storage free
              126       storage   storage length
    condition 127       CIB       result code
    promote
    condition goto
              128       dsa
    attention 129
    debugger  130       result code
    program check
    message   131       msg.sub.-- text
                                  ddname
    redirect
    CALL CEETEST
              132       + +dsa    cmd string
    ______________________________________

• Inventors
  Carney, William Peter; England, Laurence Edward; Hochmuth, Gary John; Owings, Brian; Porter, Eric Lynn; Shannon, Alfred William; Wilson, Robert Aaron;
• Assignee
  International Business Machines Corporation (Armonk, NY)
• Published
  Jun-30-1998
• Current US Classes:
  717/126
• Application #
  159063
• International Classes
  G06F 007/20
• Field of Search
  364/DIG. 395/700 395/650 395/707 395/708
• Examiner
  Toplu; Lucien U.
• Agent
  Dawkins, Esq.; Marilyn Smith Sterne, Kessler, Goldstein & Fox P.L.L.C.
• US Patent References:
  4041467
  4862349
  4868745
  4916610
  4992971
  5075847
  5097533
  5146593
  5218699
  5230049
  5355484
  5455949