Computer program product for synchronizing static variable initialization and reference under a multi-threaded computer environment

Abstract

The present invention is a computer program product to avoid static variable initialization and reference conflicts in a multi-threaded computer system. There are four major problems that arise with computer programs containing static variable references and static variable initializations on a computer system with a multi-threaded operating system: (1) premature references made on an uninitialized static variable; (2) side effects caused by initialization competition among threads; (3) multiple initialization of the same static variable; and (4) server control of static variable reference and initialization. Each of these four problems is eliminated by the system and method of this invention. The invention operates by locking the CPU during identification of the first thread seeking to initiate a static variable operation, maintaining all other threads in a wait state, and unlocking the CPU thus releasing the waiting threads from their wait state. Another component of the invention provides an additional control mechanism to invoke the disclosed static variable controller to eliminate potential static variable conflicts among competing threads.

Claims

Having thus described our invention, what we claim as new and desire to secure by Letters Patent is:

1. A computer program product for enabling a processor in a computer system to control static variable operations including initialization and reference in a multi-threaded computer system having a central processing unit (CPU) and an operating system, said computer program product comprising:

a computer usable medium having computer readable program code means embodied in said medium for causing an application program to execute on the computer system, said computer readable program code means comprising

a computer readable first program code means for causing the computer system to receive a lock request from a first thread, wherein said first thread is the first thread to request CPU processing of at least one static variable operation;

a computer readable second program code means for causing the computer system to switch said CPU to a single thread mode, wherein only said first thread is processed by said CPU during the single thread mode;

a computer readable third program code means for causing the computer system to label said first thread after said step of switching said CPU to a single thread mode; and

a computer readable fourth program code means for causing the computer system to switch said CPU to multiple thread mode, wherein multiple threads are processed by said CPU during the multiple thread mode.

2. The computer program product of claim 1, wherein said computer readable third program code means for causing the computer system to label said first thread further comprises a computer readable fifth program code means for causing the computer system to initialize a semaphore, wherein said semaphore indicates said lock request has been granted.

3. The computer program product of claim 1, wherein said lock request is in response to a static variable initialization instruction.

4. The computer program product of claim 1, wherein said lock request is in response to a static variable reference instruction.

5. The computer program product of claim 1, further comprising a computer readable fifth program code means for causing the computer system to execute a static variable initialization instruction.

6. The computer program product of claim 1, further comprising a computer readable fifth program code means for causing the computer system to execute a static variable reference instruction.

Description

CROSS-REFERENCE TO RELATED APPLICATION

The following is a related, commonly owned, co-pending application:

System and Method for Synchronizing Static Variable Initialization and Reference Under a Multi-Threaded Computer Environment, U.S. patent application Ser. No. 08/911,184

TECHNICAL FIELD

The present invention relates in general to a computer program product to avoid static variable initialization and reference conflicts in a multi-threaded computer system.

BACKGROUND ART

Multi-threaded computer systems are computers with operating systems that allow a machine's resources (for example, central processing unit (CPU), input/output interface, memory, and peripherals) to be used by multiple instruction streams (threads) in parallel. In a multi-threaded computer environment, the operating system allocates CPU processing among competing threads in a round robin fashion enabling parallel processing of instruction streams. When instruction streams are executing independent processes, multi-threaded environments are an efficient means to maximize use of CPU resources. However, in many cases instruction streams will have interdependencies created by references to certain types of variables in a computer program. With multiple threads being processed in parallel, competition and conflict among the threads can occur when multiple threads attempt simultaneous reference or initialization of certain variables.

Static variables are variables declared in a computer program that have static storage duration. Once declared, computer memory for a static variable remains allocated until the termination of the program. All references to a static variable from any portion or subroutine of a computer program refer to the memory location that was allocated for that variable. Multiple copies of the contents of the static variable memory location are not created as they might be for non-static variables. The value stored in the memory location corresponding to a static variable will always contain the last value written to this location throughout program execution.

There are four major problems that arise when computer programs containing static variable references and static variable initialization on a computer system with a multi-threaded operating system: (1) premature references made on an uninitialized static variable; (2) side effects caused by initialization competition among threads; (3) multiple initialization of the same static variable; and (4) server control of static variable reference and initialization. Each of these four problems that exist in the art are outlined briefly below.

Since the values of static variables persist across references to the static variable, static variables are shared by threads which have access to them. Without initialization and reference synchronization among the threads, it is likely that some threads can access uninitialized static variables. A premature attempt to access a static variable can cause serious program errors during run-time. For instance, if the first thread executes the initialization of static variable A, and before the initialization is complete, control of the CPU is given to the second thread, this second thread can try to reference static variable A. Since the initialization of A has not been completed by the first thread, a run-time error can occur.

Potentially multiple threads are competing for the ability to initialize a static variable. If the sequence in which a thread gains control of the CPU does not correspond with the initialization intended by the program logic, it is possible to have an out-of-sequence initialization. For example, initializing the first static variable in a function can require an operation that opens a file, and initializing the second static variable can require an operation that writes to a record in the file with the assumption the file has been opened by the initialization of the first variable. A situation can occur where the first thread is initializing the first static variable when the second thread starts initializing the second static variable. The second thread can try to write the record to the file before the file was opened. This can also cause a run-time error.

Since multi-threading is controlled by the operating system, conventional multi-threaded computer systems rely upon the compiler to generate code that guarantees that a static variable will be initialized only once. However, conventional systems are limited in that they can only satisfy this guarantee for single-threaded applications. When executing multi-threaded applications compiled by existing compilers on these systems, it is possible that while executing a multi-threaded application, two or more threads can execute the initialization of the same static variable. As discussed previously, the consequence of two or more threads attempting to execute an initialization of the same static variable can be a run-time error.

It is difficult to implement server level mechanism to control static variable references. The server not only has to be able to know which client thread is invoking the server's static variable control, but the server also must synchronize communication among the threads at the same time that it is performing static variable control. Because of the coding difficulties, the responsibility of static variable control is commonly moved into the client code. A client is a computer system that uses the instruction processing resources of another computer, either directly attached to the client or connected to the client through a computer network. Programs that rely on code running on the client to control static variables is generally considered ill-designed and has proven to be difficult to maintain and debug. Additionally, this kind of client-driven static variable control will not work in situations where the application requires static variable control by the server.

The present invention provides a solution for each of the four difficulties discussed above that are not adequately addressed by the conventional art. Prior to the reduction of this invention to practice, there was no current compiler design and implementation for generating guarded executable code to protect static variables from competing initialization and reference. Without such protection, serious run-time errors will result that are extremely hard for the users to debug, since these errors are caused by the compiler, not the user's code.

DISCLOSURE OF INVENTION

The present invention is a computer program product for the control of static variable initialization and references (SVIR) in a multi-threaded computer environment. This invention was designed to eliminate the potential sources of unreliability identified above in the Background Art section that result from competing threads running a multi-threaded application with static variable control.

A significant problem in the art solved by this invention is best illustrated by the following example. Table 1 contains a partial listing of machine code corresponding to a C/C++ function involving a static variable initialization. The code in Table 1 is the machine code that would be generated by the Borland C/C++ compiler for the OS/2.TM. operating system.

                  TABLE 1
    ______________________________________
    Assembly code for static variable initialization
    generated by the Borland C++ compiler.
    Code                        Statement
    ______________________________________
    CMP         byte ptr $eijmlgaa, 0
    JNE         short @66
    B
    INC         byte ptr $eijmlgaa
    C
    ; static initialization placed here
    $eijmlgaa label   byte
    db        0
    ______________________________________

                  TABLE 2
    ______________________________________
    Example use of SVIR execution control means.
    ______________________________________
    .sub.-- Void Client(void *argument)
    // Insert the following four statements at the
    beginning of
    // the block.
    set first thread = 0;
    declare semaphore;
    svir.sub.-- execution.sub.-- control(lock, semaphore, first.sub.--
    thread);
    if (|first.sub.-- thread) svir.sub.-- execution.sub.-- control(wait,
    semaphore, first.sub.-- thread);
    SVIR instruction 1;
    SVIR instruction 2;
    . . .
    SVIR instruction n;
    svir.sub.-- execution.sub.-- control(unlock, semaphore,
    first.sub.-- thread);
    // Multi-threaded execution resumes
    non-SVIR instruction;
    non-SVIR instruction;
    . . .
    }
    ______________________________________


              TABLE 3
    ______________________________________
    A C++ implementation of the example in table 2.
    ______________________________________
    .sub.-- Void Client(void *argument)
    // Insert the following four statements at the
    // beginning of the block.
    int first thread = 0;
    static HEV sem;
    static HEV dummy1 = ssvirlock, sem, first.sub.-- thread);
    if (|first.sub.-- thread) ssvir(wait, sem, first.sub.-- thread);
    // Insert code including SVIR instructions here.
    *   *   *
    // Insert this statement right after the last static
    // variable definition.
    static HEV dummy2 = ssvir(unlock, sem, first.sub.-- thread);
    // Insert any other non-SVIR code here.
    }
    ______________________________________

• Inventors
  Wang, I-Shin Andy; Korenshtein, Roni;
• Assignee
  International Business Machines Corporation (Armonk, NY)
• Published
  Dec-22-1998
• Current US Classes:
  718/100
  718/102
  718/106
• Application #
  940205
• International Classes
  G06F 009/40
• Field of Search
  395/672 395/673 395/676 395/677 395/670
• Examiner
  Oberley; Alvin E.
• Agent
  Johnson; Prentiss W. Sterne, Kessler, Goldstein & Fox PLLC
• US Patent References:
  5404521
  5421013