JP2000250755A - Application program developing method and computer system for platform at time of distributed adaptive execution - Google Patents

Abstract

PROBLEM TO BE SOLVED: To develop a program without describing the details of distribution and application by achieving the application in the case of distributed adaptive execution while using a metha-object programming model. SOLUTION: An adaptive object 20 is executed by one adaptive software method 21 and two non-adaptive software methods 22 and 23. Access to three implementations 21a-21c included in the adaptive software method 21 is controlled by a software selector 24 including a reference to one of them and a switching software wrapper 25. When the adaptive software method 21 is called, which implementation is to be executed is inquired to the software selector 24 by the switching software wrapper 25 and according to the reference stored in the software selector 24, selected one of implementations 21a-21c is executed.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for developing an adaptive software application program for a distributed adaptive runtime platform, a computer device, and a software platform.

[0002]

BACKGROUND OF THE INVENTION Advances in software technology have enabled computers to perform a wide variety of useful operations. Computers rely on software installed on individual storage devices, but are used for many purposes. For example, computers are capable of managing many financial transactions, controlling the production of products ranging from automobiles to integrated circuit chips, recording acquaintance addresses and telephone numbers, science and technology, in addition to sending and receiving data. Used to analyze statistical data, create and edit documents. By connecting a plurality of computer devices via a network, the functions of the computer devices can be enhanced and their usefulness can be increased.

[0003] Recent advances in hardware and software technology have also enabled the Internet. The Internet is a worldwide collection of computer networks and a gateway using TCP / IP sites as protocols for communicating with one another. Millions of people use the Internet for communication and entertainment. In addition, the Internet has been added with new functions such as digital broadcasting and digital telephone, and has been rapidly developed as a new type of network such as a wireless network and a home network. Due to the popularization of the Internet and the continuous growth of functions, large-scale distributed software applications (large-scale distri
buted software applications are promising. However, there are high barriers to their development.

[0004]

The development of large-scale distributed software applications is often complex and requires software designers to develop all kinds of services that manage distributed processes such as synchronization and communication between software modules. This is a time-consuming process. Further, when developing a distributed application, it is difficult to predict the communication media and latency used in the distributed application. Nor is it possible to predict the number of people using distributed applications. Properties that commonly appear in distributed applications, such as persistency, fault-tolerance, and replication, are complex software procedures that are inherently difficult to perform.

In recent years, a number of techniques have been developed to facilitate the development process in this area. Distributed objects and systems, such as the Common Object Request Blocker Architecture
These techniques, such as t Broker Architecture (hereinafter CORBA), simplify the process of creating distributed software applications by removing the complexity of a distributed network environment from programmers. Nevertheless, various problems in developing distributed software applications have not been eliminated. One of the problems facing application designers is that it is difficult to control the performance of distributed applications. Various factors, such as the format, content and size of the audio / video stream, or the effective mobility and connectivity of the mobile computer, greatly affect the speed and effectiveness of the application. Other factors, such as the undocking of mobile computers, facilitate the encryption of communications as well as related distributed applications that coordinate their consistent protocols. Changes in one or some of these factors require a quick and appropriate adaptation of the application to provide the performance expected by the user.

[0006] To satisfy these demands, distributed applications must be adaptive. Distributed applications need to be widely applicable and flexible enough to adapt quickly. One solution is adaptive behavior (behavio
r) into individual applications.
However, this solution places too much burden on the programmer and is not feasible. Rather, what is needed is a distributed application that can be quickly and appropriately adapted to a general application structure (application fr.
amework). What is further needed is a way to develop adaptive distributed applications in a relatively abstract and intuitive way.

[0007] That is, it is an object of the present invention to provide a method, a computer apparatus and a platform that allow a designer to develop an adaptive software application program for a distributed adaptive runtime platform without describing the details of the distribution and application. To provide.

[0008]

SUMMARY OF THE INVENTION An adaptive software application program development method for a distributed adaptive run-time platform according to the present invention is provided for an adaptive adaptive run-time platform having an adaptive manager for controlling the adaptability of a large number of objects. Developing a software application program, receiving an application source file of the adaptive software application program, and analyzing the application source file to identify a predetermined class stored in the application source file. Detecting the number of implementations of the adaptive software method when the adaptive class includes the adaptive software method and generating the first instance of the adaptive class. Extending the constructor of the adaptation class by inserting a first set of instructions into the application source file that causes a selector to dynamically select one of the applications, and when the first instance of the adaptation class terminates Extending the destructor of the adaptive class containing the adaptive software method by inserting a second set of instructions for removing the selector into the application source file.

A computer according to the present invention is a computer device for developing an application program for a distributed adaptive runtime platform having an adaptation manager for controlling the adaptability between a number of adaptive objects, the application source of the adaptive software application program. Means for receiving a file, means for parsing the application source file and detecting predetermined keywords for identifying an adaptation class stored in the application source file, and wherein the adaptation class includes an adaptation software method, Generating a first instance of the application software, the first instruction set causing the application software to generate a selector that dynamically selects one of a number of implementations of the adaptive software method. Means for extending the constructor of the adaptive class by inserting it into the application source file, and by inserting a second set of instructions for removing the selector into the application source file when the first instance of the adaptive class is finished. Means for extending a destructor of an adaptive class including an adaptive software method.

[0010] The software platform according to the present invention is a software platform for developing a general-purpose distributed adaptive application in a computer device. And a compiler for compiling the low-level generated code into machine-executable code. The precompiler detects the keyword and, if the keyword indicates that the adaptation class includes an adaptation software method, the predetermined compiler that generates the software selector upon generation of the first instance of the adaptation class. Extend the constructor of the apply class by inserting one instruction set into the application source file.
Further, the precompiler may execute a predetermined second process for deleting the software selector when the first instance is completed.
The destructor of the applicable class is extended by inserting the instruction set in the application source code.

In the present invention, an adaptation mechanism is incorporated into the runtime environment along with a set of services that support the features of distributed programming. In particular, the incorporation of adaptation mechanisms into the runtime environment allows distributed applications to adapt to ever-changing system, network and application characteristics.

Also, in the present invention, the software platform provides support for two adaptation mechanisms, a reflection method and an adaptation method. Designers can customize the execution environment of an object at run time with a reflection method, and can prepare several implementations for the same method with an adaptation method so that the most efficient Implementation can be selected. Since the software platform according to the present invention supports both the reflection method and the adaptation method, a large-scale distributed application can be easily developed using the software platform.

[0013] The software platform according to the present invention further includes an adaptation manager for configuring and managing the execution environment of the distributed application. The adaptation manager coherently adjusts the adaptability of multiple objects by keeping track of adaptation classes and instances of platform services that use them. The adaptation manager also records the adaptation process and monitors system status and user preferences. The adaptation manager performs related operations based on the adaptation process and the state of the system to determine which objects should be adapted and how and when.

The present invention assists in writing the complex code required by the platform so that application designers can access the platform service directly and intuitively, and provides easy access to the services provided by the platform. Provide a compiler to make it. The compiler, among other things, analyzes the source code of the application and translates certain keywords into the code needed to execute the reflection and adaptation methods.

[0015] The present invention includes a process for compiling an application program for a distributed adaptive runtime platform, which analyzes an application source file of the application program and detects predetermined keywords to identify an adaptive class. Extending the constructor of the adaptation class when the adaptation class contains an adaptation method to generate a selector for the adaptation method when the adaptation class is materialized; and When included, extend the constructor of the adaptive class,
Generating a reflector for the reflection method when the adaptation class is materialized.

[0016]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS A method for developing an adaptive software application program for a distributed adaptive runtime platform, a computer device, and a software platform according to the present invention will be described below with reference to the drawings.

I. Notation and Terminology Some portions of the detailed description that follow are based on symbols that represent steps, procedures, logic blocks, processing, and manipulation of data bits in computer memory. Is represented by These descriptions and notations are the methods used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art.
Procedures, logic blocks, processes, steps, and the like are generally used herein to refer to steps or instructions that lead to a desired result.
struction). The process is a physical process of physical quantity (physical quantity).
cal manipulation). Usually, though not necessarily, these quantities are in the form of electrical or magnetic signals that are stored, converted, combined, compared, and otherwise processed in the computing device. In principle, in order to handle them in common, these signals are represented by bits, values, elements, and symbols.
l), character, term, number
Expressing as etc. has often proven convenient.

It should be noted, however, that all of these and similar terms are associated with the appropriate physical quantities and are merely convenient labels applied to these physical quantities. In the following description, unless otherwise specified, the present invention uses "generating", "parsing", "extending", "calling", "executing", and the like. It is recognized that descriptions using terms such as, refer to the operation and processing of a computing device or similar electrical computing device. A computer device or similar electrical computing device processes data represented as physical (electronic) quantities in registers and memory of the computer device and separates data represented as physical quantities in the memory of the computer device. Alternatively, the data is converted into another data expressed as a physical quantity in an information storage device, a transmission or display device.

II. Computer Device Environment The features of the present invention are described below in terms of steps performed on a computer device. The present invention can be realized using various computer devices. For example, the computer device 10 shown in FIG.
form).

Computer device 10 for implementing the present invention
Is an address / data bus 11 for transferring information, a central processor 12 for processing information and instructions, a volatile memory 13 for storing information and instructions for the central processor 12, and a static information and instructions for the central processor 12. And a non-volatile memory 14 for storing the The volatile memory 13 is, for example, a random access memory (RAM)
The nonvolatile memory 14 comprises, for example, a read only memory (ROM), which are connected to the central processor 12 via an address / data bus 11.
Further, the computer device 10 includes a data storage device (disk sub device) 15 for storing information and instructions. The data storage device 15 includes, for example, a fixed or detachable magnetic disk or optical disk and a disk drive device thereof. . The data storage device 15
Is a computer-readable recording medium.
One or more removable magnetic or optical recording media, such as a floppy disk or magnetic tape, may be included. Therefore, the computer device 10 includes the volatile memory 13, the nonvolatile memory 14, and the data storage device 15 as writable and / or readable devices.

The computer device 10 includes a communication device 16 for interfacing with another computer device or the Internet. The communication device 16 comprises, for example, a modem (modem) or a network interface card (NIC), and has an address / data bus 11. It is connected to the. As shown in FIG. 1, the computer device 10 includes an input device 17 including character symbols and function keys. The input device 17 transmits information and commands to the central processor 12 via the address / data bus 11. Send selection. Further, the computer device 10 includes:
A cursor control or pointing device 18 is provided which communicates information and command selections entered by the user to the central processor 12 via the address / data bus 11. In addition, the computing device 10 may include a display 19 for displaying information to a computer user.
The display 19 also has the address / data bus 11
It is connected to the. The display 19 is, for example, a liquid crystal display,
It consists of other types of flat panel displays, cathode ray tubes or other display devices suitable for displaying graphic images and text symbols recognizable to the user.

The user of the computer uses the cursor control device 18 to dynamically instruct the two-dimensional movement of the cursor displayed on the display screen of the display 19. The cursor control device 18 includes, for example, a trackball, a mouse, a touch pad, a joystick, and the like, as is well known in the art, and is used to issue an instruction for moving the cursor in a given direction and distance. . Further, the cursor control device 18 can be realized by, for example, a special key provided on the character input device 17. Further, for example, the movement of the cursor may be instructed by a combination of a special key provided on the character input device 17 and another key. Further, the movement of the cursor may be instructed by another method such as a voice command.

III. Architecture of the Platform of the Present Invention
The present invention provides a software platform for adaptive distributed applications. In one embodiment, the software platform is implemented as computer instructions stored in readable code on a volatile memory 13, non-volatile memory 14, or data storage device 15 available on the computer. Here, the Distributed Adaptive Run-t
ime: Hereinafter, DART. One embodiment of the present invention, known as), is described.

According to the present invention, adaptation in DART is achieved by using a meta-object programming model. By using the meta-object programming model, DART provides a clean set of mechanisms for software developers building adaptive distributed applications. Further, the meta-object programming model allows distributed applications to operate well in universally changing environments such as the Internet. Meta-object programming also allows application developers to develop applications for one environment, such as the Internet, and to rewrite or rebuild applications without requiring a narrow bandwidth mobile network. It can be easily ported or ported for another environment such as. Yet another advantage of the present invention is that the system node can dynamically reconfigure itself to meet the changing needs of the application.

A. DART Adaptation Mechanism In the present invention, adaptation involves the following methods: (1) changing the execution of an object at run time; Achieved by extension. The present invention provides two mechanisms for handling these adaptive approaches. Here, in the present invention, the first adaptive approach is referred to as adaptive methods, and the second adaptive approach is referred to as reflective methods. Adaptation methods are typically used when the function code of the application itself must adapt to changes in the environment. Reflection methods, on the other hand, are typically used when the evolution of the environment changes how an application runs.

Adaptive Method FIG. 2 is a block diagram for explaining the operation of the adaptive method according to the present invention. As shown in FIG. 2, the adaptation object 20 has one adaptation software method (adap
tive software method 21 and two non-adaptive software methods 22,
23. Adaptive software method 21
Are three implementations
21a, 21b, and 21c are included. The non-adaptive software methods 22, 23 can be externally accessed by other objects. On the other hand, the implementations 21a to 21c cannot be directly accessed from outside by other objects. Access to the implementations 21a-21c is accomplished by a software selector that includes a reference to one of the implementations 21a-21c.
selector 24 and a switching software wrapper 25. As shown in FIG. 2, when the adaptation method 21 is invoked, the switching software wrapper 25 asks the software selector 24 which implementation is to be executed and
4 executes the selected one of the implementations 21a-21c according to the references stored in it.

The adaptation method of the present invention allows a programmer to directly manipulate adaptation within an application by providing several implementations with different attributes for the same method. The present invention provides a compiler that enables software developers to easily and intuitively implement adaptive methods in application programs. Also,
The present invention provides an adaptation manager that manages such adaptation methods at runtime.

Reflection Method FIG. 3 is a block diagram for explaining the operation of the reflection method of the present invention. As shown in FIG. 3, a base object (base object) 31 includes three meta-level objects (meta-level objects) 32a, 32b,
Metaspace (meta-space) 32 composed of 32c
It is linked to. In the present invention, the meta-level objects 32a-32c of the metaspace 32 are generic services (gene
ral service). As shown in FIG. 3, the base-level object 31 includes a reflection software method 33 and a software meta-wr
apper) 34 and a non-reflection software method 35.

Next, the operation will be described. The non-reflective software method 35 can be externally accessed by other data objects. When the reflection software method 33 is called, the software metal wrapper 34 calls the non-reflection software method 35 and supplies information and parameters of the reflection software method 33 called by the non-reflection software method 35. Then, the non-reflection software method 35 sets all meta-level objects 32a in the meta-level object 32.
To 32c are sequentially executed. Note that some of the meta-level objects 32a to 32c can be set to be inactive (inactive).

The reflection method of the present invention allows the programmer to specify at run time the nature of the object's execution environment (featur
e) can be customized. For example, the meta-level object 32a may be a replication meta-object. In this case, when the reflection software method 33 is called, the meta-level object 32a
Base-level object 3 whenever selected
Automatically executed to duplicate one. The present invention provides a compiler that enables a software developer to easily and intuitively implement a reflection method in an application program. The present invention also provides an adaptation manager that manages such reflection methods at runtime.

Adaptation Manager In the present invention, an adaptation manager is provided for coordinating and managing runtime adaptability. In one embodiment, when a DART application starts, an adaptation manager is created and initialized with the application's adaptation information. Thus, the adaptation manager is aware of the various adaptive classes in the application and the meta-level objects available for these classes.
At runtime, each instance of the adaptation class
Registers itself with the adaptation manager,
The adaptation manager creates a reflector / selector, depending on the nature of the adaptation class, and initializes the metaspace with the associated meta-level objects.

FIG. 4 is a block diagram for explaining the operation of the adaptation manager of the present invention. As shown in FIG. 4, the adaptation manager 41 adjusts the adaptability of two different adaptation objects 42 and 51. The adaptive object 42 includes a base object 43, meta objects 44a, 44b, 44c, a meta wrapper 45, and a reflector 46. As shown in FIG. 4, the adaptive object 51 includes a base object 52, a software selector 53, a software switching wrapper 54,
Adaptive method 55 and two non-adaptive methods 56 and 57
including. Further, the adaptation method 55 includes three implementations 58a, 58b, 58c selected by the software selector 53.

In the present invention, as shown in FIG. 4, the adaptation manager 41 can directly access the reflector 46 and the software selector 53. For example, the adaptation manager 41 may change the reflector 46 to point to the meta-object 44a so that whenever the reflection method 48 is called, the meta-object 44a is executed. Also, for example, the adaptation manager 41 can change the software selector 53 to point to the implementation 58c.
Then, when the adaptation method 55 is called, the implementation 58c is executed. Therefore,
The adaptation manager 41 provides a software mechanism for accessing the adaptation objects 42 and 51 and a software mechanism for switching between the reflector 46 and the software selector 53 at the time of execution. This architecture allows, for example, synchronized changes.
nges), enable effective jumps to the metaspace and call adaptation methods, while protecting fine adaptation such as shared meta-spaces. In the present invention, the adaptation manager 41
Can manage a group of adaptive objects simultaneously.

B. DART Compiler One important advantage of the software platform of the present invention is that application designers can easily and intuitively access platform services. In the present invention, if the DART compiler is based on, for example, Open C ++,
RT application source file (DRAT applicati
It is provided to automatically generate the low-level code needed to execute the adaptation and reflection methods from some simple keywords embedded in the on source file. With the DART compiler of the present invention, platform services are relatively uninterrupted (seam
It can be used less, transparently, and helps programmers focus on the high-level design of the application rather than the low-level mechanisms associated with distribution and adaptation.

Definition of Adaptive Class In the present invention, application designers can adapt adaptive classes by incorporating DART keywords into the DART application.
ss), for example, to describe and define which methods are adaptive or reflected, attributes of various implementations, etc. For example, as one embodiment, in the application source code, a prefix (pre-fix) of “DART_” is added as a DART keyword so that identification is possible. For example, specifically, the adaptation class is identified by the DART keyword “DART_Class”, and the reflection method is identified by the DART keyword “DART_Reflective”.
The DART keywords "DART_Adaptive", "D
ART_Impl ". DA of the present invention
The RT Compiler uses these DART keywords as identifiers, and when the DART keywords are found, all the code needed to set up the reflector / selector and adaptation manager and manage multiple implementations and metaspaces is taken. Occurs automatically. In addition, the DART compiler of the present invention adds additional methods required to support adaptability, such as an introspection method and an alteration method, to the application source code. .

By using the DART compiler of the present invention, a programmer can specify the nature of the default meta-space of a class,
By specifying the method to be reflected, the reflection method can be easily executed. Also, adaptation methods can be implemented by specifying various implementations with their respective attributes. Then, the DART compiler automatically extends the constructor of the base class that operates the reflection method and the adaptation method. In particular, D
The ART compiler extends the constructor of the base class to create a new object of the adaptation class each time it creates its own reflector and selector for each defined adaptation method. Also, the base class constructor creates a new object with the runtime adaptation manager (ru
It is extended to register with the n-time adaptation manager).

In addition, the DART compiler automatically extends the destructor of the base class so that each time a new object is terminated, this terminated new object will have its own for each of the defined adaptive methods. It deletes its own reflector and selector and also deletes its registration with the runtime adaptation manager.

Tables 1 and 2 show specific examples of the definition of the adaptation class according to the present invention, for example, the DART classes "Counter" and "V".
ideoFilter ”respectively.

Table 1 DART_Class class Counter {DART_MSSetDefault DART_LGP; private: int cpt; public: Counter (); DART_Reflective void Incr (); DART_Reflective void Decr (); DART_Reflective int Val (); DART_Reflective void Set (int val); ;

Table 1 shows the adaptive class "Counter" of the distributed application program. As shown in Table 1, the application developer sets the adaptation class “Co
The meta-object "DART_LGP" has been selected as the default meta-object for the meta-object associated with "unter". Methods "Incr ()", "Decr ()", "Va
l () "and" Set "are all defined as reflection methods of the adaptive class" Counter ". Therefore, in the present invention, the reflection method (for example, the method “Incr ()”, “Decr
Each time one of “cr ()”, “Val ()”, “Set”) is called, the meta-object “DART_LGP” is automatically executed. In this example, the meta-object "DART_LGP"
Automatically maintains the consistency of duplicate instances of the adaptation class "Counter" whenever one of the reflection methods is invoked. That is, the application designer does not need to care about the inherent details of implementing an adaptive application. Rather, the code that the application developer must add is minimal, and this code represents a high level of information in the application's adaptation requirements.

Table 2 DART_Class class VideoFilter {Stream * st; VideoFilter (); DART_Adaptive (Send_BW) int Send (group * dest); DART_Impl int Send_BW (group * dest); DART_Impl int Send_COL (group * dest); DART_Property Send_BW ( NETWORK_BANDWIDTH, LOW); DART_Property Send_COL (NETWORK_BANDWIDTH, HIGH);};

Table 2 shows the DART class "VideoFilter" for the distributed video application program. As shown in Table 2, the DART class “VideoFil
ter "is two implementations" Send_BW ",
One adaptive method "Send" defined in "Send_COL"
Contains. In the DART class in this specific example, the application transmits an image in black and white when the network bandwidth is small, and transmits the image in color (Send_COD) when the network bandwidth is wide by the adaptive method “Send”.
L). Further, as shown in Table 2, the implementation "Send_BW" has been selected as the default implementation. Thus, whenever the adaptation method "Send" is invoked, the implementation "Send_BW" is executed. Thus, the present invention frees application developers from the complex details of implementing adaptation. The DART compiler automatically generates the code needed to set up the adaptation manager and manage multiple implementations.

FIG. 5 is a block diagram for explaining specific processing when a DART application is compiled by the DART compiler of the present invention.

As shown in FIG. 5, the DART keyword (for example, the DART class “Counte
r ”,“ VideoFilter ”) is the application source file 61
It is supplied to a compiler 62. Also. DART compiler 62 includes a number of adaptive service imple- ment files that contain a predefined set of rules for processing DART keywords.
mentation file) 63 is provided. And DART
The compiler 62 generates a low-level generated source code (low-le
vel generated source code) 64 and configuration file (con
figuration file) 65 is generated. The low-level source code 64 includes duplicate and erroneous code for generating an adaptation manager and is provided to a C ++ compiler 65, which comprises, for example, gcc and compiles the low-level source code 64. To generate an execution file 66. The configuration file 65 is used to supply initialization information to the adaptation manager at runtime. Table 3 shows a specific example of the low-level generated source code generated by the DART compiler for the DART class “Counter”.

Table 3 ############################################### ########################### # 4268 “Counter.ii” class Counter {private: int cpt; // These three new member variables are added by the dart // compiler and correspond to //-the unique object ID given to the DART object //-a pointer to the intermediate structure that // holds the un / marshalling //-a pointer to the reflector associated with the // base object ObjectID * Dart_id; MetaClass * Dart_mc; Reflector * Dart_reflector; Counter (); // For each reflective method X, a new method BaseLeve1X is // added to the class.The code of the BaseLeve1X method will // be the one written by the class designer for the method X. // The method X has a new body that contains the calling code // to the meta-level (see below) void BaseLevelIncr (); void BaseLevelDecr (); int BaseLevelVal ( ); void BaseLevelSet (int val); // This is the new code for the Incr method.First, create // a bitstring with: // an identifier for t he intermediate structure to use, // the method number, and // the parameters (in the case of this method, // there is n0 parameter). // After the bitstring is complete, the Reflector of the // object is called to perform the Before call on all the // meta-objects. // A CallBefore is done with providing to the meta-objects // the bitstring containing the method name and call // parameters, along with the base-object ID.The return code // of the CallBefore is used to decide whether or no the // base-level code of the method should be executed. // After that step, the CallAfter is performed with the same // parameters as the Ca11Before. // Finally, if a meta-space call returned a valid return // code, it is returned, otherwise, the return code of the // base-level call is used (in this case, no return code is // associated with this method ) void Incr () (void * tm_res = O, * tmp_res2 = O; u_char * msg_, * msg_O_; msg_O_ = new u_char [40000]; msg_ = msg_O_; msg_ + = Dart_mc-> marshall_mC (msg_, O); * ((int *) msg_) = O; msg_ + = sizeof (int); tmp_res = Dart_reflector-> CallBefore (Dart_id, O, msg_O_, (msg_-msg_O _), O); if (tmp_res = = 0) (this -> BaseLevelIncr ();} tmp_res2 = Dart_reflector-> CallAfter (Dart_id, 0, msg_O_, (msg_-msg_O _), O); free ((void *) msg_ O_);}; void Decr () {void * tmp_res = O, * tmp_res2 = O; u_char * msg_, * msg_0_; msg_O_ = new u_char [40000]; msg_ = msg_O_; msg_ + = Dart_mc-> marshall_mc (msg_, O); * ((int *) msg_) = 1; msg_ + = sizeof (int); tmp_res = Dart_reflector-> CallBefore (Dart_id, O, msg_O_, (msg_-msg_O _), O); if (tmp_res = = 0) (this-> BaseLevelDecr ();} tmp_res2 = Dart_reflector- > CallAfter (Dart_id, 0, msg_O_, (msg_-msg_O _), O); free ((void *) msg_ O_);}; // In this case, a return code (integer) is associated with // the method. If a valid pointer is received form the // meta-level calls (either before or after), the void * // pointer is cast to the correct format.int Val () {int res; void * tmp_res = O, * tmp_res2 = O; u_char * msg_, * msg_0_; msg_O_ = new u_char [ 40000]; msg_ = msg_O_; msg_ + = Dart_mc-> marshall_mC (msg_, O); * ((int *) msg_) = 2; msg_ + = sizeof (int); tmp_res = Dart_reflector-> CallBefore (Dart_id, O, msg_O_, (msg_-msg_O _), l); if (tmp_ = res == O) {res = this-> BaseLeve1Va1 ();} tmp_res2 = Dart_reflector-> CallAfter (Dart_id, 0, msg_O _, (msg_- msg_O_), l); free ((void *) msg_O_); if (tmp_res! = O) {free ((void ') tmp res2); return (' ((int *) tmp_ res));} if (tmp res2! = 0) (return (* ((int *) tmp_res2));} return (res);}; // In this case, no return value is expected but there is a // parameter.Thus, when creating the bitstring, the value // of the int is added after the method identifier.There is // no description of the format of the bitstring (except for // the intermediate structure and the method identifiers) .void Set (int val) {void * tmp_res = O, * tmp_res2 = O; u_char * msg_, * msg_0_; msg_O_ = new u_char [40000]; msg_ = msg_O_; msg_ + = Dart_mc-> marshall_mc (msg_, O); * ((int *) msg_) = 3; msg_ + = sizeof (int); memcpy (msg_, & val, sizeof (int)); msg _ + = sizeof (int); tmp_res = Dart_reflector-> CallBefore (Dart_id, O, msg_O_, (msg_-msg_O _), O); if (tmp_res = = 0) (this-> BaseLevelSet (val);} tmp_res2 = Dart_reflector -> CallAfter (Dart_id, 0, msg_O_, (msg_-msg_O _), O); free ((void *) msg_ O_);}; // After the wrappers for the reflective methods, the DART // compiler is also generating automatically methods in the // class to marshall and unmarshall the object (create a // bitstring from an object state and vice-versa. // The first method allows the object to create a bitstring // from the object state.Here, the bitstring is only // composed of the integer containing the counter value.static u_char * marshall (void * obj, u_char * p, size t len) (Counter * b = (Counter *) obj; * ((int *) p) = b->cpt; p + = sizeof (int); len-= sizeof (int); return p;} // This method initializes the state of the object from a // bitstring.static u_char * unmarshall_rec (void * pobj, u_char * p, size_t len) (Counter * obj = (Counter *) pobj; obj-> cpt = (int) (* ((int *) p)); p + = sizeof (int); len-= sizeof (int); return p;} // This method takes a parameter bitstring and performs the // call to the correct method with the correct parameters.static size_t unmarshall_func (void * vobj, u_char * p, u_char * r, size_t len) {Counter * obj = (Counter *) vobj; u_char * r0 = r; int methid = * ((imt *) p ); p + = sizeof (int); switch (methid) {case O: {obj-> BaseLevelIncr (); break;} case 1: {obj-> BaseLevelDecr (); break;} case 2: {int retval = obj-> BaseLevelVal (); if (r) {memcpy (r, & retval, sizeof (int)); r + = sizeof (int);} break;} case 3: {int p0; memcpy (& pO, p, sizeof (int)); p + = sizeof (p0); obj-> BaseLevelSet (pO): break;} default: break;} return r-r0;}}; // Another important part rewritten by the DART compiler is // the constructor of the class.The original constructor is // first executed, and after all the instructions for the // adaptive object are initialized. //-initialization of the unique identifier of the object //-in itialization of the intermediate structure //-creation of the reflector. // Then, a reference to the DART manager is obtained, and // register the currently created object (together with // it's ID, intermediate structure class name and // reflector ) .It is during the registration that the DART // manager checks for the given class and the Configuration // of the meta-space, and eventually creates the requested // meta-object.Counter :: Counter () {// original constructor {cpt = 0;} // added instructions Dart_id = & (ObjectID :: get_unique ()); Dart_mc = new MetaClass ("Counter", marshall, unmarsha11, unmarshall_func); Dart_reflector = new (Reflector); AdapManager * Dart_M; Dart_M = GetAdapManager (); Dart_M-> RegisterObject ((void *) this, Dart_id, Dart_mc, "Counter", Dart_reflector);｝; // Below are the original code for the reflective methods void Counter :: BaseLevelIncr () {cpt ++ ;} void Counter :: BaseLevelDecr () {cpt--;} int Counter :: BaseLevelVal () {return (cpt);} v oid Counter :: BaseLevelSet (int val) {apt = val;} ################################### #######################################

Here, even after the DART compiler converts the source code, the name of the non-reflection method remains unchanged, but the name of the reflection method is
The meta wrapper with "X" changed to "BaseLevel_X" and the name X is inserted into the class definition. Therefore, in the source code, the method "obj->
When "X" is called, the metal wrapper is compiled and then called by the DART compiler.

Further, in one embodiment of the present invention, the metaspace call is made before and / or after the execution of the base level method. Thus, in the present invention, a meta-level object is a C ++ object that provides at least two methods before and after a metaspace call. Further, in order for the meta-level object to function properly, the meta-level object often must introspect the base object to obtain parameters such as the name of the invoked method, the value and type of the variable. In the present invention, introspection methods and alteration methods are automatically generated by the DART compiler and inserted into the generated source code when the adaptive class is processed. In a development of the invention, the variables of any member of the base object can be identified, accessed and modified by the introspection method and the alteration method. In addition, the meta-object can execute any method of the base object and organize / unorganize the state of the object by the introspection method and the alteration method.
/ unmarshall). Also, in order for the meta-object to have access to the base-level introspection and alteration methods, the DART compiler uses an intermediate structure that links the metaspace to the base level.
ture) to allow any meta-object to access introspection and alteration methods at the base level in the generated source code.

C. Coherent runtime adaptation according to the invention
Management In the present invention, it is advantageous to adjust the adaptability of multiple objects of the application in a coherent manner. In the present invention, coherent and consistent runtime adaptation management is achieved by three runtime elements:

(1) An adaptation event generated depending on system statistics, user requests, and the like.

(2) Adaptation processing (adaptation pol) that responds to a special event and is applied to a special object
icies).

(3) An adaptation manager that activates an appropriate adaptation process depending on a received event, and controls adaptation performed to avoid instability and inconsistency.

Adaptation Event and Adaptation Processing Many adaptation objects share the same basic resource.
When sharing ces), it is important to adapt them in a consistent manner so that instability can be avoided. For example, for a video conferencing application having an adaptive video channel object and an adaptive audio channel object, it is desirable to adapt the video channel object before adapting the audio channel object. In this way, the over-correction or ping-pong effect
effects).

Thus, to achieve consistent adaptability between multiple adaptation objects, the software runtime platform provides a set of “system level” adaptation events that represent changes in the system. Providing and allowing the user to define "system-level" adaptive processes that respond to these events in the application. In the present invention, the adaptation event is generated externally by various elements such as a system statistics server, a user control panel, or internally by any object that can access the adaptation manager.

In the present invention, system events are further refined by the libraries or the application itself to generate more specific events.
e) is done. It is up to the application designer to set the desired adaptability at a more detailed level. For example, network conflicts (contentio
When n) is detected, the system statistics server sends a system event "NETWORK_CONT" to the adaptation manager. When the multimedia library's adaptation for the system event "NETWORK_CONT" is registered with the adaptation manager, the adaptation manager performs the adaptation to detect problems in the video and audio streams.
If the video stream is found to be using too much of the network's bandwidth, the adaptation process triggers the event "VIDEO_STRE
AM_CONT "to the adaptation manager. Upon receiving the event “VIDEO_STREAM_CONT”, the adaptation manager receives the event “VIDO_STREAM_CONT”.
Call the adaptation process registered in the multimedia library for "EO_STREAM_CONT" to adapt the video channel object to send only black and white images.

Further, in the present invention, the adaptation processing is realized by a library designer and an application designer to control the adaptability of the adaptation object. These adaptation processes utilize the services of the adaptation manager to obtain information on the adaptability characteristics of the application and modify adaptation objects such as configuring metaspaces or executing adaptation methods. In the present invention, the application designer can identify a specific adaptation process for the adaptation method or the reflection method by the keyword “DART_Policy”. Also, the designer can identify particular adaptation events associated with the adaptation process in the application source code. DART compilers generate the low-level code needed to associate processing with events when pre-compiling application source files. In addition, whenever an application is run, processes and events are registered with the adaptation manager. That is, in the present invention, the adaptation process is removed or installed (installed) by the adaptation manager at the time of execution.

Further, in the present invention, adaptive processing is performed at three different levels: system, middleware (midd).
leware) and adaptive processing. Also, each process
Part of a module. Here, the module is used by a user / application designer to easily select or inhibit a certain adaptive process. For example, when the multimedia group communication protocol is used in its own adaptive processing, it is better to prohibit the adaptive processing of the general-purpose group communication protocol.

Table 4 shows a specific example of the DART class including the DART processing according to the present invention.

Table 4 DART_Class class Hello {public: Hello (char * name) {person = (char *) malloc (80); strcpy (person, name);} DART_Policy LangStrategy (APP_LEVEL, 0, LANG_EVENT); DART_Property print_fr ( LANG_PROP, LANG_PROP_FR); DART_Property print_jp (LANG_PROP, LANG_PROP_JP); DART_Adaptive (print_jp) void print (); DART_Implementation (print) void print_fr (); DART_Implementation (print) void print_jp (); private: char * person;}

Table 4 shows the DART adaptive processing "LangStrateg".
Here is a simple class definition "Hello" containing "y".
The adaptation process is an application level (APP_LEVEL) process as shown in Table 4, and the adaptation event “LANG_EVENT”
It is activated when receiving. Application processing "Lang
Strategy "is itself provided by the application developer and is written as a simple C function. In the present invention, the application process “LangStrategy” implements the “print_f” implementation of the adaptation method “print” for all of the application's adaptation objects.
r ”and“ print_jp ”to control the adaptation manager.

Adaptive Processing Using DART Manager API
Executing Logic For example, the adaptation process in DART is a simple C function using an adaptation manager to search for a particular instance of a class (the class associated with the adaptation process).
The adaptation process also instructs the adaptation manager to search for a particular attribute in the adaptation method and a particular meta-object in the reflection method. In the present invention, a set of adaptation manager application programming interfaces (application programming interfaces) is provided to simplify the adaptation software development process.
e: Hereinafter, API. ) Is provided. The software developer performs an adaptation process that can use the API, searches for a particular adaptation object, changes the metaspace configuration, finds a selector / reflector for the adaptation object, and changes the reflector / selector of the adaptation object. be able to. Table 5 shows a specific example of the adaptation manager API according to the present invention.

Table 5 / ******************************************** *************** / / * This file give some of the API provided by the DART manager for writing adaptation policies. * / / ************ *********************************************** // * ****************************************************** ******** / class AdapManager {/ ************************************* ********************** / / * allow to find a given meta-object given base-object unique identifier * / MetaObject * FindMetaObject (int mo_id, ObjctID * obj_id); / ********************************************** ************* / / * add and remove a specific meta_object to an instance of an object * / int AddMetaObject (ObjectID * obj_id, int meta_obj_type); int RemoveMetaObject (ObjectID * obj_id, int meta_obj_type ); int AdMetaObject (char * class_name, int meta_obj_type, int flag); int RemoveMetaObject (char * class_name, int meta_obj_type, int flag); / ******************* **************************************** / / * clear the meta-space of a base-object (removes all it's meta-object) * / int ClearMetaSpace (ObjectID * obj_id); int ClearMetaSpace (char * class_name, int flag); / *************** ******************************************** / / * build a group of adaptive objects by sharing the meta-space * / int TransferMeta (AdapObject * tmp_dest, AdapObject * tmp_src); int TransferMeta (ObjectID * id_dest, ObjectID * id_src); / ************** ********************************************* / / * make a base-object uses it's own meta-objects if in a group before * / int DisconnectMeta (AdapObject * tmp_obJ); int DisconnectMeta (ObjectID * obj_id); / ***************** ****************************************** / / * build a group of adaptive objects by sharing the selectors * / int ShareSelectors (AdapObject * obj1, AdapObject * obj2); / ****************************** ***************************** / / * makes an object use its own selector for adaptive methods (leaves the group) * / int LocalSelectors (AdapObject * obj1); / *************************** ******************************** / / * register an adaptation policy in the DART manager * / int RegisterAdaptation (int event_nb , int level_id, int mood_id, void ((* fn) (AdapManager *, ObjectID *, int, int argc, char * argv [])), int flag); / * activate / deactivate a set of adaptation policies from a module * / int SetModule (int action, int module); / * activate / deactivate an adaptation policy * / int SetFn (int action, void ((* fn) (AdapManager *, ObjectID *, int, int argc, char * argv [ ]))); / * activate / deactivate a set of policies for a level (system / lib / application) and / or the one that react on a gven event / * int SetLevel (int action, int level_id, int event_nb); / * inhibit an event from being fired * / int DeleteEvent (int event_nb); / ******************************** *************************** / / * return a list of function names given different parameters (property, class name) * / List * GetFunctions (int prop, char * class_name); / * return a list of selectors given different parameters * / List * Get Selectors (List * objs, char * class_name, char * fn_name); / * return a list containing one / all instances of a given adaptive class * / List * GetObjects (ObjectID * obj_id, char * class_name); / * return the default implementation to use for an adaptive method of a class * / int GetDefault (char * class_name, char * fn_name); / * set the value of the selector (for all instance of a class and for a given function) * / int SetSelectcrs ( char * class_name, char * fn_name, int value); / * set the value of the selector (for all selectors in the list) * / int SetSelectors (List * sels, int value); / * activate / deactivate a given type of meta-object for a list of base-object) * / SetMetaObject (List * objs, int mo_id, int op);};

FIG. 6 is a block diagram illustrating an embodiment of the DART architecture of the present invention. As shown in FIG. 6, a specific DART framework (framework) 70 includes an application program 71 and three libraries 72.
a, 72b, 72c, an adaptation manager 73, and an operating system (OS) 75. The three libraries 72a, 72b, 72c are, for example, a distributed library 72a, a multimedia library 72, respectively.
b, a group communication library 72c. Application program 71 and three libraries 72a-
Reference numerals 72c each include an adaptation object 74 registered in the adaptation manager 73. The adaptation process 76 and the adaptation event 77 are registered in the adaptation manager 73.
In the present invention, the adaptation process indicates the fitness of the registered object based on the associated adaptation event.

As shown in this specific example, upon receiving the registered adaptation event 77a from the operating system 75, the adaptation manager 73 searches for an appropriate adaptation process 76a related to the adaptation event 77a, and Execute And the adaptation manager 73
The adaptive process 76a searches and selects a specific adaptive object 74 in the application program 71 and the multimedia library 72b. In this way, the adaptability of a large number of adaptation objects is effectively and efficiently adjusted.

As another example, if the application program 71 has an adaptive object class “ARRAY” that includes an efficient implementation of the network and a memory efficient implementation, the application designer may specify the event “MEN_LOW”. And a memory process that causes the adaptive manager 73 to select an efficient implementation of memory in all instances of the adaptive object class "RRAY" upon detection of the event "MEN_LOW" can be registered in the adaptive manager 73. At execution, the OS 75 can generate the event “MEN_LOW”. Therefore, adaptation manager 7
3 receives the event “MEN_LOW”, searches all instances of the adaptive object class “ARRAY”,
Choose an efficient implementation of memory for each instance.

D. Distributed application using DART
The adaptation library provides other services that deal with distribution, such as adaptation classes, meta-level objects, and adaptation processing, while the building adaptation mechanism is provided by the core DART platform. Distributed class (di
distributed classes) are replicated objects (replicate
d objects), synchronization and persistence (pe
When there is a distributed metaspace that provides rsistency, it can be easily constructed. In the present invention, the adaptive distributed library is implemented on a DART platform. For more information on implementing an adaptive distributed library, see Sony Corporation's 1998 DS.
L-USRL Technical Report
ny DSL-USRL Technical Report 1998 Raverdy, PG)
"Distributed objects for DART middleware (Dist
ributed Objects for the DART Middleware).

Duplicate Meta-Level Objects The meta-level objects provided in the distributed library of the present invention provide easy access to distributed protocols. Main meta-level objects control the replication of base objects. Replicated objects provide an intuitive and natural way to build distributed applications compared to group communication.

In particular, the replication protocol to which the present invention is applied has two independent layers. The lower layer handles the communication and broadcasts a light adaptive group protocol (multicas) shared by several replicated objects.
t) Use the protocol. The upper layer handles the replication and controls the transmission of updates, management of consistency and updates of local replicas. This upper layer implements several replication protocols that provide the best service to the base object according to the requirements of the application, such as active and passive replication, master-proxy. . The generic interface between both layers is available in various network and replication configurations (sche
adjust me).

In the present invention, the protocols executed include passive duplication, active duplication, and master proxy. In passive replication, one replication (master) at any given moment has the exact state of the base object and has access to the base object. Another replica requests the correct status from the master replica when it wants to use the base object, and uses the base object when it receives the correct status. In active replication, each time any replica accesses an object, updates are sent to other replicas. The update is a function update or data update, for example, a function update such as a function name or parameter is sent to a remote replica, which must operate locally. Also, updates to data, such as the state of new objects, are sent to remote copies, which need to update their local copy of the data. In the master proxy protocol, the master is responsible for managing object updates. Other replicas that send updates require the name of the method they want to execute along with the parameters for the master's copy.

The object of the duplicate meta level is DAR
Use some of the special methods of the base class generated at compile time by the T compiler to clean up or not clean up the state of duplicate objects. Thus, application designers need only identify DART replication meta-level objects as the default metaspace for replicating classes,
s), object locking, initializing state, master selection (master)
There is no need to write code for election. However, the application designer must decide which methods and member variables should be duplicated and which protocol should be used. Table 6 shows a specific example of an application realized using the duplicate meta-object according to the present invention.

Table 6 DART_Class class SharedBoard (DART_Local Display * my_display; OBJ_List my_list (); DART_MSSetDefault DART_LGP; SharedBoard (); DART_Reflective void AddObj (int x, int y, SharedObj Obj); Redraw ();}

As shown in Table 6, the meta-object “DA
"RT_LGP" is a default meta-object of the class "SharedBoard" class. Class "SharedBoard"
Includes a reflection method "AddObj". In the present invention, when the reflection method “AddObj” is called at the time of execution, the object “SharedBoard” is copied. In the present invention, the meta-object "DART_LGP" supports active functions and data output, passive data output and master proxy protocol.

FIG. 7 is a block diagram showing a specific example of the interaction between two copies of a distributed object at the time of copying. As shown in FIG. 7, the distributed object 80
One copy 81, 82 is included. The replica 81 includes a base object 83, three meta-level objects 87, a reflector 86, a metal wrapper 85, a reflection method 84, and a special method 88. The replica 82 is similar to the replica 81 and includes a base object 90 and one meta-object 89.

The operation will now be described. Duplication 81
When the reflection method 84 is called, the meta wrapper 85
Calls a reflector 86, which calls objects 87 at different meta levels. The meta-level selected object 87 that controls replication is a DA
The local special methods generated by the RT compiler are used to get the state of the object and send it to other replicas 82. Meta-level object 89 updates its local base object to the new state.
Therefore, the distributed object 87 is easily and automatically copied. In this way, distributed application developers can take advantage of the various adaptation mechanisms provided by this software platform,
Complex distributed applications can be realized with minimal effort.

In the present invention, by using the adaptation manager, the object
1,82 adaptability can be managed. The replication adaptation process is registered with the adaptation manager and, when an event is detected, calls the adaptation manager to change the configuration of the replication metaspace. In this way, the replication protocol:
It changes dynamically at run time.

For example, a distributed application can use an active replication meta-object as its own default protocol for replication. According to one embodiment of the present invention, the distributed application includes an adaptive process to change the metaspace and includes a passive replication meta-object upon detecting a sudden change in network bandwidth or usage. be able to.
With the present invention, the adaptation is automatic and the application designer does not need to write code to handle the adaptability.
Rather, the adaptation service is pre-installed in the runtime software environment.

In the present invention, the adaptation manager is used at run time to manage the adaptability of the duplicate meta-level objects 81,82. The adaptation process for duplication is
When registered with the adaptation manager and an event is detected,
The adaptation manager is called to change the configuration of the replication metaspace. In this way, different replication protocols can be used in different network environments, and the application designer does not need to write special code to handle the adaptability.

As described above, the present invention, that is, the distributed adaptive runtime (DART) software environment has been described.
Within the ART environment, application behavior, attributes and needs, environment characteristics, and adaptive processing can be independently designed. Also, the DART environment is expanded by several adaptation mechanisms and a general purpose mechanism for adaptation management. By using adaptive events and processes, mutual luck between independent adaptive objects can be achieved. Another advantage of the present invention is that application developers do not need to know the details of the adaptation.

As another advantageous feature of the present invention, DART
The compiler forms an adaptive control structure to initialize the configuration of the platform. The generated code, e.g., introspection and alteration methods at the base level, introduces basic functions that are dynamically coupled at runtime to complex operations such as replication and persistence . Also, the application designer has very fine control over the components of the class and can independently extend the variables and methods of the class. By using a software runtime environment in accordance with the present invention, application developers can rapidly develop distributed software, such as network or web software, without having to deal with the details of distributed technology.

The present invention is not limited to the above embodiment, but should be interpreted based on the claims.

[Brief description of the drawings]

FIG. 1 is a block diagram illustrating a specific configuration of a computer device that implements the present invention.

FIG. 2 is a block diagram for explaining an operation of an adaptive method according to the present invention.

FIG. 3 is a block diagram for explaining the operation of a reflection method according to the present invention.

FIG. 4 is a block diagram for explaining the operation of the adaptation manager of the present invention.

FIG. 5 is a block diagram for explaining the operation of the DART compiler of the present invention.

FIG. 6 is a block diagram showing a specific example of the DART architecture of the present invention.

FIG. 7 is a block diagram showing a specific example of the interaction between two copies of a distributed object at the time of copying.

[Explanation of symbols]

10 computer device, 11 address / data bus, 12 central processor, 13 volatile memory, 14
Non-volatile memory, 15 data storage device, 1
6 communication device, 17 input device, 18 cursor control device, 19 display device, 20 adaptive object, 21 adaptive software method, 21a-21c implementation, 22, 23 non-adaptive software method, 24 software selector, 25 switching software wrapper

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Roger Jay Lee California, USA 95134-1901 Santa Clara Zankar Road 3300 Sony USR Inside Distributed Systems Laboratory

Claims (25)

[Claims] 1. A method for developing an adaptive software application program for a distributed adaptive runtime platform, the method comprising: developing an adaptive software application program for a distributed adaptive runtime platform having an adaptation manager for controlling the adaptability of a number of objects; Receiving an application source file of a software application program; analyzing the application source file to detect a predetermined keyword for identifying an adaptive class stored in the application source file; Including an adaptation software method, when creating a first instance of the adaptation class,
Extending the adaptive class constructor by inserting a first set of instructions into the application source file that generates a selector that dynamically selects one of a number of implementations of the adaptive software method; Extending a destructor of the adaptive class containing the adaptive software method by inserting a second set of instructions for removing the selector into the application source file when the first instance of the adaptive class is terminated; Method for developing an adaptive software application program for a distributed adaptive runtime platform having 2. The method according to claim 1, further comprising the step of inserting a third instruction set for registering a first instance of the adaptation class with the adaptation manager into the application source file at the time of materialization. Changing the selector according to a change in the execution environment of the adaptive software application program at the time,
2. The method according to claim 1, further comprising controlling the adaptability of an instance of the application. 3. The method of claim 1, wherein the adaptation class includes a reflection software method, and a fourth instance of generating a reflector that dynamically defines a metaspace of the reflection software method when generating a second instance of the adaptation class. Extending the constructor of the adaptive class by inserting the set of instructions into the application source file; and defining a fifth set of instructions for removing the reflector when a second instance of the adaptive class terminates. Extending the destructor of the adaptive class containing the reflected software method by inserting it into the application source file. The method of developing an adaptive software application program for a distributed adaptive runtime platform according to claim 1, comprising: 4. The method according to claim 1, further comprising the step of inserting a sixth instruction set for registering a second instance of the adaptation class in the adaptation manager into the application source file at the time of reification. 4. The distributed adaptive runtime platform according to claim 3, wherein the adaptiveness of the second instance is controlled by changing the reflector according to a change in the execution environment of the adaptive software application program at the time. How to develop an adaptive software application program for Windows. 5. Inserting a seventh instruction set into the application source code that automatically generates a switching wrapper for the multiple implementations, the switching wrapper comprising: 2. An adaptation for a distributed adaptive runtime platform according to claim 1, wherein when is called, one of the multiple implementations is selected in response to information stored in the selector. Software application program development method. 6. The method according to claim 6, further comprising the step of: inserting an eighth instruction set into the application source file for automatically generating a meta-wrapper for the reflection software method, wherein the meta-wrapper is configured to call the reflection software method. 4. The method according to claim 3, wherein parameters of the reflection software method are provided in the reflector. 7. Inserting a ninth set of instructions into the application source file that generates an introspection method that causes the meta-object to obtain an internal state of a second instance of the adaptation class. 4. The method for developing an adaptive software application program for a distributed adaptive runtime platform according to claim 3, comprising: 8. Inserting a tenth set of instructions into the application source file that forms an intermediate structure that causes the meta-object to access a base level of a second instance of the adaptation class. A method for developing an adaptive software application program for a distributed adaptive runtime platform according to claim 7. 9. A computer system for developing an application program for a distributed adaptive runtime platform having an adaptation manager for controlling the adaptability between a number of adaptive objects, comprising: means for receiving an application source file of the adaptive software application program; Parse the above application source file,
Means for detecting a predetermined keyword for identifying an adaptation class stored in the application source file; and when the adaptation class includes an adaptation software method and generating a first instance of the adaptation class,
Means for extending the adaptive class constructor by inserting a first set of instructions into the application source file that generates a selector that dynamically selects one of a number of implementations of the adaptive software method; Means for extending a destructor of the adaptive class including the adaptive software method by inserting a second set of instructions for removing the selector into the application source file when the first instance of the adaptive class is terminated; Computer equipment. And means for inserting a third instruction set for registering an instance of the adaptation class in the adaptation manager into the application source file at the time of materialization, wherein the adaptation manager executes the adaptation at execution time. By changing the selector according to a change in the execution environment of the software application program, the first
The computer device according to claim 9, wherein the adaptability of the instance of is controlled. 11. The method according to claim 11, wherein the adaptation class includes a reflection software method, and a fourth instruction set for generating a reflector that dynamically determines a metaspace of the reflection software method when a second instance of the adaptation class occurs. Means for extending the constructor of the adaptation class by inserting it into the application source file; and a fifth instruction set for removing the reflector when the second instance of the adaptation class is terminated. Means for extending a destructor of the adaptive class containing the reflection software method by inserting it into a file. And means for inserting a sixth instruction set for registering an instance of the adaptation class in the adaptation manager into the application source file at the time of materialization, wherein the adaptation manager executes the adaptation at the time of execution. The computer device according to claim 11, wherein the adaptability of the second instance is controlled by changing the reflector according to a change in an execution environment of a software application program. 13. The method of claim 7, further comprising automatically generating switching wrappers for said multiple implementations.
Means for inserting the set of instructions into the application source code, wherein the switching wrapper is configured to execute the plurality of implementations in response to the information stored in the selector when the adaptive software method is invoked. The computer device according to claim 9, wherein one is selected. 14. The system further comprising means for inserting an eighth instruction set into the application source file for automatically generating a meta wrapper for the reflection software method, wherein the meta wrapper is called when the reflection software method is called. 12. The computer device according to claim 11, wherein parameters of the reflection software method are provided in the reflector. 15. The method according to claim 9, further comprising generating an introspection method that causes the meta-object to obtain an internal state of a second instance of the adaptive class.
The computer device according to claim 11, further comprising means for inserting the instruction set into the application source file. 16. The application source file further comprises means for inserting a tenth set of instructions forming an intermediate structure that causes the meta-object to access a base level of a second instance of the adaptation class. The computer device according to claim 15. 17. A software platform for developing a general-purpose distributed adaptive application in a computer device, comprising: a precompiler for converting source code of an adaptive software application into which low-level generated code incorporates keywords for describing and defining an adaptive class. And a compiler that compiles the low-level generated code into machine-executable code. The precompiler detects the keyword and determines that the adaptive class contains an adaptive software method. If so, by inserting a predetermined first instruction set for generating a software selector into the application source file when generating the first instance of the adaptive class, Extending the destructor of the applicable class by inserting a predetermined second instruction set for deleting the software selector into the application source code when the first instance is completed, while extending the first instance. A software platform characterized by: 18. The precompiler may further comprise: if the keyword indicates that the adaptation class includes a reflection software method, a second one of the adaptation class.
The constructor is extended by inserting a predetermined third instruction set for generating a software reflector into the application source code when generating the instance of the software instance, and when the second instance is completed, the software reflector is extended. The software platform of claim 18, wherein the destructor is extended by inserting a predetermined fourth set of instructions into the application source code that removes the destructor. 19. The software platform according to claim 18, further comprising an adaptation manager that controls the adaptability of a number of adaptation objects of the software application program. 20. The precompiler inserts, into the application source file, a fifth instruction set for registering the first instance in the adaptation manager at the time of materialization, wherein the adaptation manager executes the adaptation software at the time of execution. 20. The software platform according to claim 19, wherein the adaptability of the first instance is controlled by changing the selector according to a change in an execution environment of an application program. 21. The precompiler inserts, into the application source file, a sixth instruction set for registering the second instance with the adaptation manager at the time of materialization, wherein the adaptation manager executes the adaptation software during execution. 20. The software platform according to claim 19, wherein the adaptability of the second instance is controlled by changing the selector according to a change in an execution environment of an application program. 22. The precompiler inserts into the application source code a seventh instruction set that automatically generates the switching wrappers for the multiple implementations, wherein the switching wrapper includes 19. The software platform of claim 18, wherein when invoked, one of the multiple implementations is selected in response to information stored in the selector. 23. The precompiler inserts, into the application source file, an eighth instruction set that automatically generates a meta-wrapper for the reflection software method, wherein the meta-wrapper is configured to execute when the reflection software method is called. 19. The software platform according to claim 18, wherein parameters of the reflection software method are provided in the reflector. 24. The precompiler inserts a ninth set of instructions into the application source file that generates an introspection method that causes the meta-object to obtain an internal state of a second instance of the adaptation class. 19. The method according to claim 18, wherein
Software platform as described in. 25. The precompiler inserts a tenth set of instructions into the application source file forming an intermediate structure that causes the meta-object to access a base level of a second instance of the adaptation class. The software platform of claim 24, wherein: