Invocation map based architecture for program execution

Details Invocation map based architecture for program execution Invocation map based architecture for program execution

2000-10-04

2004-05-04

Nguyen, Van (Department: 2126)

Electrical computers and digital processing systems: multicomput

Computer-to-computer data routing

Least weight routing

C709S241000, C717S108000

Reexamination Certificate

active

06729699

ABSTRACT:

FIELD OF THE INVENTION
This invention relates to invocation map based architecture for program execution.
BACKGROUND OF THE INVENTION
Current popular software systems make use of two key concepts namely processes and procedure calls to implement any required functionality. The operating system and associated middle-ware is typically implemented as a set of system procedure calls. The applications are implemented as a set of processes, which have their own private data areas that are not accessible to other processes while executing application level code. There are also privilege levels, which allow free access for all system level memory along with address space of application under execution. There are other mechanisms such as shared memory and inter-process messages that help in inter-process communication. The operating system itself makes use of a layered architecture in which a mechanism of messages or shared memory is used to communicate between different layers. In other cases the operating system is designed, as a set of modules containing assorted procedure calls that call each other to accomplish desired functionality.
As indicated above, a typical full-blown software system, which is used for reasonably serious use, contains several layers of software. The layered structure of operating system contains kernel services, over which are layered device drivers, file systems, database engines, transaction monitors and message queuing systems and over and above these are windowing and GUI related software. The complex applications within themselves have many modules and layering. Accomplishing any task involves passing of information through several layers of software back & forth. As each layer is designed to be as general purpose and generic as possible there are chances of sub-optimal implementation and performance penalties. There have also been increasing popularity of data encapsulation and information hiding with the increasing use of object oriented techniques. This again calls for extensive use of messages between different execution units of code. The object-oriented implementations again make use of significant amount of message passing that in turn has scope for performance degradation.
Most of the procedural invocations make use of stacks which implies repeated copying of parameters starting from a procedure that provides inputs all the way to the procedures that performs the last part of processing.
Another point to consider is that a typical end-user executes a set of frequently used and related applications on his system such as a browser, a word-processor, and a spreadsheet program and may be a mail client. If there are mechanisms which allow a tighter integration and collaborative execution by way of easier sharing of data then the system performance can be significantly enhanced.
Even in an industrial strength application, certain execution paths are more frequently used and a tighter integration between the relevant modules can lead to greater execution efficiencies. When the integration is loose, there is lot of duplication of similar functions in different modules and also tendency to grow the size of software by an overwhelming expansion of feature set. This could make the frequently used operations inefficient as they carry the overhead of large amount of rarely used code as part of the execution image.
With the availability of massive parallel, symmetric multi-processor, NUMA and cluster technologies, it becomes possible to migrate applications from a client-server environment to a high performance server centric environment that can exploit the tight integration of disparate elements of the system in one place. Also cheap availability of huge memory pools again opens up new opportunities for architectural innovation. The availability of machines with bigger machine words makes higher liner (virtual) addresses achievable for programs running even on low-end machines.
In summary, existing system architectures, based on stack-oriented parameter passing between procedures, are subject to the following limitations:
Performance penalty owing to the overhead of loading parameters onto the stack and unloading parameters from the stack for each instance of a procedure call,
Unnecessary duplication of similar functions in different modules of an application leading to execution inefficiencies,
Poor integration between frequently used and related application,
Inefficient support of symmetric multiprocessor, parallel computing, NUMA and cluster technologies for performance enhancement.
THE OBJECT AND SUMMARY OF THE INVENTION
The object of this invention is to obviate the above mentioned drawbacks and provide an efficient system of parameter passing that avoids unnecessary duplication of functions and supports effective integration of applications and multi-processing environment.
To achieve the said objective, this invention provides in a computing system containing at least one processor, memory and storage devices and input and output devices, said computing system executing software programs in which parameters are passed to procedures characterized in that it includes an invocation map data structure means for passing parameters to a procedure without using the stack for more efficient operation.
The said invocation map data structure means has the facility to be used repeatedly.
The said invocation map data structure means is a shared data repository for several procedures.
The said invocation map data structure means includes the facility to be shared across nested procedures.
The said invocation map data structure means is derived from a hierarchical declaration map means based on calling relationships between procedures, comprising assigning level numbers to each level in the procedure calling hierarchy.
The said invocation map data structure means is constructed to capture the complete hierarchical relationship between the procedures.
A new invocation map data structure means is created and used if the existing invocation map data structure means is in use and a concurrent execution is desired.
A new invocation map data structure means is created or a free invocation map data structure means is used if procedure recursion is required.
The said invocation map data structure means is created with a unique map identification and is structured as follows:
Invocation Map {Procedure Name
Instance ID
Invocation Map Identifier
Use-flag
Save-flag
Saved_program_counter
Pointer to Parametric data
Pointer to Private Data
Pointer to sibling invocation map
Pointer to child invocation map
Pointer to next invocation map for same procedure
Pointer to Parent invocation Map
}
The ‘use flag’ for a procedure invocation map data structure means is set to ‘1’ at the start of the execution and reset at the end of the execution of a procedure.
The ‘Save Flag’ in said invocation map data structure means saves the parameters for reuse by a subsequent invocation of the procedure.
The said invocation map data structure means is constructed to initialize any parameter within its enclosed procedural hierarchy including initialization before calling at the structure level so as to avoid creation of multiple copies of the said parameter.
The said invocation map data structure means support recursion and iteration of procedures for which the number of times the procedure will be invoked is known only during run-time.
The data areas for said invocation map data structure means are pre-allocated and can grow along with program execution.
The said invocation map data structure means is declared only once using hierarchical declaration map and referred from anywhere.
The said invocation map data structure means is created as an .imap file during procedure compilation and contains the declaration of the procedure in its own hierarchical map.
The said invocation map data structure means is visible only within the scope of related procedures.
Each invocation of the invocation map data structure means is allocated a separate data area accessible only by its owning thread, such d

Affiliated with

Also associated with

Rating

Invocation map based architecture for program execution does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Invocation map based architecture for program execution, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Invocation map based architecture for program execution will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-3199657