A system and method is provided to facilitate communications between object systems. A caller is provided having optimized in-lined functionality when initiating a remote function call between managed and unmanaged object systems, for example. The in-lined functionality includes utilizing direct calls and returns within a calling function. In this manner, pushing additional arguments onto an execution stack because of an external stub reference is mitigated. In addition, one or more code loops can be analyzed to enable stack markers to be “hoisted” and thus pushed a single time instead of each time the calling function executes. Other aspects of the optimized caller provide garbage collection and thread management, security attribute checking on outgoing calls, calling convention considerations, wherein arguments and return values are organized according to the convention utilized by the remote object system, and in-lined marshalling to provide enhanced performance over external stub code references. Code extensibility options can be included enabling functions to be generalized thereby insulating object systems from implementation details of the called functions.
|
29. A system that facilitates communication, the system comprising:
a caller component that is associated to a first component, the first component being managed code;
a second component that is invoked by an in-lined stub within the caller component, the second component is unmanaged code, the in-lined stub facilitates communication and execution management between the components.
1. A system that facilitates communicating between managed and unmanaged code, comprising:
a first component that is managed code; and
a caller associated with the first component, the caller invokes an object related to a second component, the second component being unmanaged code, the caller's code includes an in-lined stub that facilitates communications to and execution management of the object.
36. A system that facilitates communications between disparate objects, the system comprising:
means for incorporating an in-lined stub within code of a caller, the in-lined stub includes communication and execution management functionality; and
means for providing a call and return within the caller that facilitates the communication and execution management functionality between the disparate objects.
25. A system that facilitates communications between disparate objects, comprising:
means for incorporating external stub code functionality within code of a caller, the external stub code functionality includes communication and execution management functions between the disparate objects; and
means for interfacing with the caller to facilitate the communications and management functions between the disparate objects.
32. A method of facilitating communications between managed and unmanaged code, the method comprising:
embedding an in-lined stub code within code of a calling function, the in-lined stub code includes communication and execution management functionality between the managed and unmanaged code; and
incorporating a call and return within the calling code to facilitate the communications and execution management functionality between the managed and unmanaged code.
14. A method of facilitating communications between managed and unmanaged code, comprising:
incorporating external stub code functionality in-line within code of a calling function, the external stub code functionality includes communication and execution management functions between managed and unmanaged code; and
providing a call and return within the calling code that facilitates the communication and management functions between the managed and unmanaged code.
28. A computer-implemented control system that facilitates communication between managed and unmanaged code, comprising:
a control signal that communicates data between the managed and unmanaged code; and
a caller associated with the managed code, the caller invokes an object related to the unmanaged code via the control signal, the caller's code includes an in-lined stub that facilitates communications and execution management between the managed and the unmanaged code.
27. A computer-readable medium having stored thereon, a caller that incorporates an in-lined stub that executes and manages a remote object, comprising:
a first in-lined data set providing call and return interface capabilities within the caller;
a second in-lined data set providing execution stack instructions for the caller; and
a third in-lined data set providing hoisting capabilities within the caller, the interface, the stack instructions and the hoisting capabilities enabling the execution of the remote object.
2. The system of
3. The system of
4. The system of
5. The system of
6. The system of
7. The system of
8. The system of
9. The system of
10. The system of
11. The system of
12. The system of
13. The system of
15. The method of
16. The method of
17. The method of
18. The method of
19. The method of
20. The method of
21. The method of
22. The method of
23. The method of
24. A computer-readable medium having computer-executable instructions for performing the acts of
26. The system of
30. The system of
31. The system of
33. The method of
34. The method of
35. The method of
37. The system of
38. The system of
39. The system of
40. The system of
|
The present invention relates generally to computer systems, and more particularly to a system and method to enable communications between one or more (e.g., managed to unmanaged) object systems, including in-lined stub functionality employed to facilitate operational performance and communications between the object systems.
As computer science has evolved, object oriented programming has become one of many familiar models designers and programmers utilize to implement functionality within computer systems. The object model generally is defined by a class structure that includes class members providing both methods and associated data elements belonging to the class. The class members thus provide/define desired functionality within a computer program, wherein an object is declared as an instance of a particular class. As is commonplace, objects often must exchange data and/or invoke other objects operating on the same platform and/or communicate with objects belonging to remote platforms. In order to communicate between objects, interface systems and standards have been developed to define how objects may communicate and/or interact with one another.
A familiar system for communicating and interfacing between objects is known as the Component Object Model (COM), wherein another similar system is referred to as the Common Object Request Brokers Architecture (CORBA). Still yet other communication interfaces may be defined in languages such as JAVA within an operating framework of a Java Virtual Machine, for example. As these and other systems have been developed however, two common object architectures or models generally have emerged and may generally be defined in terms of managed and unmanaged object systems, for example.
Managed objects may be allocated from a heap within a managed software environment and are generally not responsible for managing associated object lifetimes. Managed objects may be described in terms of a data type (e.g., metadata) and automatically collected (e.g., reclaimed) by a managed environment “garbage collector” that removes the object from memory when the object is no longer being accessed. In contrast, unmanaged objects may be allocated from a standard operating system heap, wherein the object itself is responsible for freeing memory it employs when references to the object no longer exist. This may be accomplished through well-known techniques such as reference counting, for example.
Managed applications and/or objects can execute calls to unmanaged Application Program Interfaces (APIs) (e.g., operating system APIs, entry points into dynamically loaded dynamic link libraries (DLLs), entry points into COM components) by a process called “platform invoke.” In general, a call from managed to unmanaged code requires some additional code to be executed as part of a transition between the two execution models. For example, this may entail: potentially marshalling a plurality of arguments and return values (e.g., depending on the actual data-type, some data-types may not have similar representations in managed and unmanaged code); locating multiple markers on an execution stack (e.g., in order that a managed system can locate “managed” and “unmanaged” segments of the execution stack); considering thread execution on return from unmanaged to managed code; and potentially managing security issues between the execution environments.
In a general situation, this can be implemented by directing the call through an external interface referred to as “stub-code” that can perform these operations. Unfortunately, one or more of these stub-code operations are particularly time intensive (e.g., as compared to a regular call of a function in the same object system). For example, by utilizing a call through the stub, stack-based arguments often need to be copied onto a different stack location (i.e., the arguments need to be pushed again)—even if marshalling for the actual data-types is unnecessary. Another problem relates to adding markers on the stack and can involve an explicit update of a linked list, for example, such that access to the root of that list is comparatively expensive (e.g., processor execution cycles). Due to these and other issues relating to communications between object systems, there is a need for a system and methodology to facilitate improved execution performance when invoking functions and/or objects between object systems.
The following presents a simplified summary of the invention in order to provide a basic understanding of some aspects of the invention. This summary is not an extensive overview of the invention. It is intended to neither identify key or critical elements of the invention nor delineate the scope of the invention. Its sole purpose is to present some concepts of the invention in a simplified form as a prelude to the more detailed description that is presented later.
The present invention relates to a system and methodology that facilitates communications and execution performance between managed and unmanaged code environments. This is achieved by providing functional aspects and considerations of an in-lined stub having portions thereof incorporated within the execution framework of a calling function between managed and unmanaged code—in lieu of calling an external interface stub at run time. In this manner, copying and/or re-pushing of outgoing functional arguments onto an execution stack are mitigated. Moreover, adding a stack marker, for example, to an explicit list of stack markers can be hoisted (e.g., separated from an actual call). Thus, in the case of multiple calls, the list can be updated a single time instead of providing an update to the list each time for respective call sites. In addition, the in-lined stub mitigates the need to marshal outgoing call arguments and return values, and reduces the need for runtime security checking between the managed and unmanaged environments.
In accordance with the present invention, a caller is provided having optimized in-lined functionality when initiating a remote function call between managed and unmanaged object systems. The in-lined functionality includes utilizing direct calls and returns within a calling function. In this manner, pushing additional arguments onto an execution stack because of an external stub reference is reduced. According to another aspect of the present invention, code loops are analyzed to enable stack markers to be “hoisted” and thus pushed a single time instead of each time the calling function executes. Other aspects of the optimized caller provide garbage collection and thread management, security attribute checking on outgoing calls, and calling convention considerations, wherein arguments and return values are organized according to the convention utilized by the remote object system. In-lined marshalling can be included to provide enhanced performance over external stub code references along with code extensibility options wherein, functions can be generalized to insulate respective object systems from implementation details of the called functions.
The following description and the annexed drawings set forth in detail certain illustrative aspects of the invention. These aspects are indicative, however, of but a few of the various ways in which the principles of the invention may be employed and the present invention is intended to include all such aspects and their equivalents. Other advantages and novel features of the invention will become apparent from the following detailed description of the invention when considered in conjunction with the drawings.
The present invention relates to a system and methodology to facilitate communications and enhanced processor execution performance between object systems. Although the present invention is described in terms of communications between managed and unmanaged object systems, it is to be appreciated that the concepts, as described herein, can be utilized to include communications between substantially any object system (e.g., managed/unmanaged, managed/managed, unmanaged/unmanaged object systems).
The present invention promotes enhanced computer execution performance via a general performance optimization for interoperation of code that can be under the control of an execution engine, virtual machine and/or other code such as unmanaged code. In order to minimize the execution overhead for the transition between object systems during communications, the present invention includes one or more optimizations within a calling function that facilitates communications between the object systems (e.g., managed to unmanaged code). According to one aspect of the present invention, a plurality of conditions can be controlled which can be statically or dynamically validated at code generation time (e.g., Just-In-Time (JIT) and/or “Pre-JIT”), wherein interface code can be in-lined into a caller in order to “speed-up” the overall execution time of a call/return pair across a managed/unmanaged boundary. Several factors can contribute to the speed-up during object system communications. For example, copying (e.g., re-pushing) of outgoing call arguments is mitigated and adding a stack marker to an explicit list of stack markers can be hoisted. In cases including multiple calls, for example, adding to the list can be achieved in a single update instead of multiple updates as with conventional systems.
Referring initially to
As illustrated, the caller 30 utilizes a direct call/return pair 44 and 46 to interact and communicate with the unmanaged object 38 rather than invoke an external stub (not shown) as with conventional systems. In this manner, stack operations such as pushing and popping arguments and return values related to the external stub are reduced thus conserving processor execution cycles. In accordance with another aspect of the present invention, a hoisting operation 50 can be provided that further mitigates code execution cycles. As will be described in more detail below, the hoisting operation 50 involves locating a stack marker (not shown) that is utilized for the return 46 from the unmanaged object 38. This is an optimization, wherein the stack marker is located outside of a code loop and placed a single time onto a return list, for example, rather than being placed/located each time the caller 30 executes as with conventional systems.
Due to the hoisting operation 50, several issues involving timing and synchronization of the call/return pair 44 and 46 between the managed and unmanaged environment are considered and accounted for that are generally not required of conventional systems. As will be described in more detail below, this can include providing one or more synchronization flags within the caller 30 to facilitate the hoisting operation 50. This can also include providing garbage collection and/or thread management code 52 to further account for these issues.
Other aspects of the present invention can include providing in-lined security attribute checking 54 within the caller 30, wherein permissions can be verified as to whether the caller 30 can invoke the unmanaged object 38. A calling convention management aspect 56 can also be provided that enables the caller 30 to organize call and return arguments according to the convention utilized by the unmanaged object 38. Another aspect includes optional inline marshalling 58 within the caller 30. This can include incorporation of data marshalling code within the caller 30 depending on desired system performance requirements. Still yet another aspect of the present invention includes providing extensibility 60 to the caller 30. As will be described in more detail below, this can include generalizing functional calls to the unmanaged object 38 such that implementation details within the calls are insulated from the caller 30 and the unmanaged object 38.
Referring now to
The calling function 110, illustrates the direct call and return management aspects of the present invention. At 120, arguments associated with the calling function are pushed onto an execution stack (not shown). These arguments, (e.g., pointers, variables) can include variable and other parameters that are utilized by the managed system and the remote object/function during execution/return of the call. At 124, a call is directed to the unmanaged code from the calling function 110. After the unmanaged code executes the remote call, a return is initiated by the unmanaged code and is illustrated at 128. At 132, return arguments provided from the unmanaged code at 124 are popped from the stack to complete the call. This may also include popping a stack marker to direct the calling function 110 back within the managed code from which the call originated.
Turning now to
Due to the hoisting operation at 224, other issues relating to synchronization and timing of a call/return pair between managed and unmanaged code are considered. For example, when the stack marker 220 is hoisted at 224, there is no longer substantial certainty that execution has transitioned from the managed environment to the unmanaged environment. This is a concern for such issues as operating with a managed garbage collector during unmanaged call execution, for example, and is described in more detail below. Thus, at 228, transition code is added to the calling function to manage synchronization at 232 between the execution of the caller 210, and a system manager such as a garbage collector that is concerned with the lifetime of the caller 210 and the area of memory in which the caller 210 exists. Therefore, one or more flags 240 are associated with the caller 210 to enable synchronization management between object systems during code execution transitions. This can include timing and consideration of such conditions (e.g., race conditions) that can occur between setting the one or more flags 240 indicating a transition from managed execution to unmanaged execution and vice versa and the actual transition that may occur at a different point in time. Other considerations involve the timing of the garbage collector and thread execution upon calls and returns between managed and unmanaged code. Also depicted with the caller 210 are related arguments and return addresses 248.
Referring now to
Referring now to
Referring to
Referring now to
Turning to
In order to provide a context for the various aspects of the invention,
With reference to
The system bus may be any of several types of bus structure including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of commercially available bus architectures. The system memory may include read only memory (ROM) 724 and random access memory (RAM) 725. A basic input/output system (BIOS), containing the basic routines that help to transfer information between elements within the computer 720, such as during start-up, is stored in ROM 724.
The computer 720 further includes a hard disk drive 727, a magnetic disk drive 728, e.g., to read from or write to a removable disk 729, and an optical disk drive 730, e.g., for reading from or writing to a CD-ROM disk 731 or to read from or write to other optical media. The hard disk drive 727, magnetic disk drive 728, and optical disk drive 730 are connected to the system bus 723 by a hard disk drive interface 732, a magnetic disk drive interface 733, and an optical drive interface 734, respectively. The drives and their associated computer-readable media provide nonvolatile storage of data, data structures, computer-executable instructions, etc. for the computer 720. Although the description of computer-readable media above refers to a hard disk, a removable magnetic disk and a CD, it should be appreciated by those skilled in the art that other types of media which are readable by a computer, such as magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges, and the like, may also be used in the exemplary operating environment, and further that any such media may contain computer-executable instructions for performing the methods of the present invention.
A number of program modules may be stored in the drives and RAM 725, including an operating system 735, one or more application programs 736, other program modules 737, and program data 738. It is noted that the operating system 735 in the illustrated computer may be substantially any suitable operating system.
A user may enter commands and information into the computer 720 through a keyboard 740 and a pointing device, such as a mouse 742. Other input devices (not shown) may include a microphone, a joystick, a game pad, a satellite dish, a scanner, or the like. These and other input devices are often connected to the processing unit 721 through a serial port interface 746 that is coupled to the system bus, but may be connected by other interfaces, such as a parallel port, a game port or a universal serial bus (USB). A monitor 747 or other type of display device is also connected to the system bus 723 via an interface, such as a video adapter 748. In addition to the monitor, computers typically include other peripheral output devices (not shown), such as speakers and printers.
The computer 720 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 749. The remote computer 749 may be a workstation, a server computer, a router, a peer device or other common network node, and typically includes many or all of the elements described relative to the computer 720, although only a memory storage device 750 is illustrated in
When employed in a LAN networking environment, the computer 720 may be connected to the local network 751 through a network interface or adapter 753. When utilized in a WAN networking environment, the computer 720 generally may include a modem 754, and/or is connected to a communications server on the LAN, and/or has other means for establishing communications over the wide area network 752, such as the Internet. The modem 754, which may be internal or external, may be connected to the system bus 723 via the serial port interface 746. In a networked environment, program modules depicted relative to the computer 720, or portions thereof, may be stored in the remote memory storage device. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be employed.
In accordance with the practices of persons skilled in the art of computer programming, the present invention has been described with reference to acts and symbolic representations of operations that are performed by a computer, such as the computer 720, unless otherwise indicated. Such acts and operations are sometimes referred to as being computer-executed. It will be appreciated that the acts and symbolically represented operations include the manipulation by the processing unit 721 of electrical signals representing data bits which causes a resulting transformation or reduction of the electrical signal representation, and the maintenance of data bits at memory locations in the memory system (including the system memory 722, hard drive 727, floppy disks 729, and CD-ROM 731) to thereby reconfigure or otherwise alter the computer system's operation, as well as other processing of signals. The memory locations wherein such data bits are maintained are physical locations that have particular electrical, magnetic, or optical properties corresponding to the data bits.
What has been described above are preferred aspects of the present invention. It is, of course, not possible to describe every conceivable combination of components or methodologies for purposes of describing the present invention, but one of ordinary skill in the art will recognize that many further combinations and permutations of the present invention are possible. Accordingly, the present invention is intended to embrace all such alterations, modifications and variations that fall within the spirit and scope of the appended claims.
Dussud, Patrick H., Krishnaswamy, Raja, Peschel-Gallee, Frank V.
Patent | Priority | Assignee | Title |
7596783, | Mar 28 2006 | Intel Corporation | Methods and apparatus to implement annotation based thunking |
7730473, | Jun 30 2004 | Intel Corporation | Relieving data marshalling overhead |
7774752, | Sep 30 2002 | Microsoft Technology Licensing, LLC | Runtime services for network software platform |
7844947, | Sep 30 2002 | Microsoft Technology Licensing, LLC | Runtime services for network software platform |
8423961, | Jun 06 2008 | Microsoft Technology Licensing, LLC | Simulating operations through out-of-process execution |
8521863, | Jan 18 2010 | Huawei Technologies Co., Ltd. | Method and device for operating resource on shared network element |
8561045, | Jul 30 2010 | Apple Inc. | Constructing runtime state for inlined code |
9146759, | Jul 30 2010 | Apple Inc. | Assumption-based compilation |
9195486, | Jul 30 2010 | Apple Inc. | Observation and analysis based code optimization |
Patent | Priority | Assignee | Title |
5491800, | Dec 20 1993 | Apple Inc | Object-oriented remote procedure call networking system |
5893121, | Apr 23 1997 | Oracle America, Inc | System and method for swapping blocks of tagged stack entries between a tagged stack cache and an untagged main memory storage |
6067580, | Mar 11 1997 | International Business Machines Corporation | Integrating distributed computing environment remote procedure calls with an advisory work load manager |
6081665, | Dec 21 1996 | AONIX, S A | Method for efficient soft real-time execution of portable byte code computer programs |
6108715, | Dec 13 1994 | Microsoft Technology Licensing, LLC | Method and system for invoking remote procedure calls |
6157961, | Dec 21 1992 | Sun Microsystems, Inc. | Client-side stub interpreter |
6393497, | Mar 20 1998 | Oracle America, Inc | Downloadable smart proxies for performing processing associated with a remote procedure call in a distributed system |
6751798, | Jul 11 1996 | Flash Networks LTD | Method and apparatus for performing distributed object calls using proxies and memory allocation |
20020091863, |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Jun 22 2001 | PESCHEL-GALLEE, FRANK V | Microsoft Corporation | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 011956 | /0607 | |
Jun 22 2001 | KRISHNASWAMY, RAJA | Microsoft Corporation | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 011956 | /0607 | |
Jun 22 2001 | DUSSUD, PATRICK H | Microsoft Corporation | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 011956 | /0607 | |
Jun 28 2001 | Microsoft Corporation | (assignment on the face of the patent) | / | |||
Oct 14 2014 | Microsoft Corporation | Microsoft Technology Licensing, LLC | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 034541 | /0001 |
Date | Maintenance Fee Events |
May 27 2009 | M1551: Payment of Maintenance Fee, 4th Year, Large Entity. |
Mar 18 2013 | M1552: Payment of Maintenance Fee, 8th Year, Large Entity. |
Jun 15 2017 | M1553: Payment of Maintenance Fee, 12th Year, Large Entity. |
Date | Maintenance Schedule |
Dec 27 2008 | 4 years fee payment window open |
Jun 27 2009 | 6 months grace period start (w surcharge) |
Dec 27 2009 | patent expiry (for year 4) |
Dec 27 2011 | 2 years to revive unintentionally abandoned end. (for year 4) |
Dec 27 2012 | 8 years fee payment window open |
Jun 27 2013 | 6 months grace period start (w surcharge) |
Dec 27 2013 | patent expiry (for year 8) |
Dec 27 2015 | 2 years to revive unintentionally abandoned end. (for year 8) |
Dec 27 2016 | 12 years fee payment window open |
Jun 27 2017 | 6 months grace period start (w surcharge) |
Dec 27 2017 | patent expiry (for year 12) |
Dec 27 2019 | 2 years to revive unintentionally abandoned end. (for year 12) |