JP2002014813A - Application program developing method for platform at the time of executing distribution and adaptation and computer device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for allowing a designer to easily develop distributed and adaptive software such as a network without describing the details of distribution or adaptation. SOLUTION: An application source file is analyzed so that a prescribed keyword for identifying an adaptive class can be detected. When an adaptive software method is included in the adaptive class, and the first instance of the adaptive class is generated, a first instruction set for generating a selector for dynamically selecting one of the plural implementations of the adaptive software method is inserted into the application source file so that the constructor of the adaptive class can be extended. When the first instance of the adaptive class is ended, a second instruction set for erasing the selector is inserted into the application software file so that the destructor of the adaptive class including the adaptive software method can be extended.

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 and a computer apparatus.

[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, a computer, in addition to sending and receiving data, manages many financial transactions, controls the manufacture of products ranging from automobiles to integrated circuit chips, records acquaintance addresses and telephone numbers, science and technology. It is 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 communication with one another. Millions of people use the Internet for communication and entertainment. In addition, the Internet has new functions such as digital broadcasting and digital telephone, and is rapidly developing 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 distri
buted software applications are promising. However, there are high barriers to their development.

[0004]

The development of large-scale distributed software applications is complex and often 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 and the associated distributed applications that coordinate their consistent protocols. Changes in one or several 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, an object of the present invention is to provide a method and a computer device by which a designer can develop an adaptive software application program for a distributed adaptive runtime platform without describing the details of the distribution and application. That is.

[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 that the adaptive class includes an adaptive software method, and when generating a first instance of the adaptive class, multiple implementations of the adaptive software method. Extends the constructor of the adaptation class so that the new object registers itself with the adaptation manager by inserting a first set of instructions into the application source file that generates a selector that dynamically selects one of the applications. Steps to
Extending the destructor of the adaptive class containing the adaptive software method by inserting a second set of instructions into the application source file to remove the selector when the first instance of the adaptive class has finished.

[0009] A computer device 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 device of the adaptive software application program. Means for receiving a source file; means for parsing the application source file to detect a predetermined keyword for identifying an adaptation class stored in the application source file; and When generating a first instance of the class, the application includes a first set of instructions that cause a selector to be dynamically selected to select one of a number of implementations of the adaptive software method. Means to extend the adaptation class's constructor by inserting it into the source file so that the new object registers itself with the adaptation manager, and remove the selector when the first instance of the adaptation class is finished Means for extending a destructor of an adaptive class containing adaptive software methods by inserting a second set of instructions into an application source file.

[0010] A computer device according to the present invention includes storage means for storing a software platform for developing a general-purpose distributed adaptive application, and a processor for executing the software platform stored in the storage means. The software platform running on the processor includes a precompiler that converts the source code of the adaptive software application into which the keywords that describe and define the adaptation class are embedded into low-level generated code, and a machine-executed low-level generated code Compiler that compiles into possible code. The processor detects the keyword by executing the precompiler and, if the keyword indicates that the adaptation class includes an adaptation software method, executes the software upon generation of the first instance of the adaptation class. Extending the constructor of the apply class such that the new object registers itself with the adaptation manager by inserting a predetermined first set of instructions that creates a selector into the application source file. Also, the processor executes the precompiler to insert a predetermined second instruction set for deleting the software selector into the application source code when the first instance is completed, thereby causing the destructor of the applicable class to be executed. Expand.

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, by incorporating adaptive mechanisms into the runtime environment, distributed applications can be adapted to constantly 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. The software platform running on the computer device according to the present invention supports both the reflection method and the adaptation method, so that large-scale distributed applications can be easily developed using this software platform.

[0013] The software platform running on the computing device 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, when, and when.

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

The present invention includes a process for compiling an application program for a distributed adaptive run-time platform, which analyzes an application source file of the application program and detects predetermined keywords for identifying an adaptive class. Extending the constructor of the adaptation class when the adaptation class contains an adaptation method to generate an adaptation method selector when the adaptation class is reified; 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 An adaptive software application program development method and a computer apparatus for a distributed adaptive runtime platform according to the present invention will be described below.
This will be described with reference to the drawings.

I. NOTATION AND TERMS Some parts of the following detailed description are based on symbols, which 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 stated, the present invention uses "generating", "parsing", "extending", "calling", "executing", and the like. It will be appreciated that descriptions using terms such as, refer to the operation and processing of a computing device or similar electrical computing device. A computing device or similar electrical computing device processes data represented as physical (electronic) quantities in registers and memory of the computing device, and separate data represented as physical quantities in the memory of the computing device. Alternatively, it is converted into another data expressed as a physical quantity in an information storage device, a transmission or display device.

II. Computer Apparatus Environment The features of the present invention will be described in the following description in steps performed on the computer apparatus. 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 can be used as a writable and / or readable device,
, Nonvolatile memory 14 and data storage device 15
It has.

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. The computer device 10 also includes a cursor control or pointing device 18, which communicates information and command selections entered by the user to the central processor 12 via an address / data bus 11. Further, the computer device 10 also has a display 19 for displaying information to a user of the computer, and this display 19 is also connected to the address / data bus 11. The display 19 comprises, for example, a liquid crystal display, another type of flat panel display, a cathode ray tube, or another display device suitable for displaying graphic images and character symbols recognizable by a 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. Furthermore, 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. Platform Architecture 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. In addition, 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, for example, the Internet, and to rewrite or rebuild applications without requiring a narrow bandwidth mobile network. Can be easily ported or ported for other environments 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 runtime, and (2) dynamically extending objects with general properties during execution. Is achieved by doing 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 application's function code 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.

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 includes 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 allows 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.

FIG. 3 is a block diagram for explaining the operation of the reflection method according to the present invention. As shown in FIG. 3, a base object (base object) 31 includes three meta-level objects (meta-level objects) 32a, 32b,
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 within 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 inactive, which is not called.

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 knows the various adaptive classes in the application and the meta-level objects available for these classes.
At runtime, each instance of the adaptation class (instance)
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 a software platform running on a computing device to which the present invention is applied is that the application designer can use a platform service (platform s).
ervices) are easily and intuitively accessible. In the present invention, when the DART compiler is based on, for example, Open (C ++), the DART application source file (DRAT application source file)
It is provided to automatically generate the low-level code necessary to execute the adaptation and reflection methods from some simple keywords incorporated in e).
The DART compiler of the present invention allows platform services to be used relatively seamlessly and transparently, allowing programmers to use higher levels of application rather than lower level mechanisms related to distribution and adaptation. Helps you to focus on designing.

Definition of Adaptive Class In the present invention, the application designer incorporates DART keywords into the DART application to create an adaptive class.
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 (DART_) of “DART_” is added as a DART keyword so that the identification can be performed. For example, specifically, the adaptation class is identified by the DART keyword “DART_Class”, and the reflection method is 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, the RT Compiler replaces all the code needed to set up the reflector / selector and adaptation manager and to manage many implementations and metaspaces. 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. .

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, and this new object 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 based on 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 adaptation requirements of the application.

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 adaptation method "Send" defined in "Send_COL"
Contains. In the DART class of this specific example, the application transmits an image in black and white when the network bandwidth is low, and transmits the image in color (Send_COD) when the network bandwidth is high 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 compiling a DART application 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 (application source file) 61
It is supplied to a compiler 62. Also. DART compiler 62 includes a number of adaptive service imple- ment files (adaptive service imple- ment files) that contain a pre-defined 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 the 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 the 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)); ms g_ + = 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 //-i nitialization 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);} void Cou nter :: BaseLevelSet (int val) {apt = val;} ###################################### ######################################

Here, even after the DART compiler converts the source code, the name of the non-reflecting method remains unchanged, but the name of the reflecting method is
The metawrapper is changed from "X" to "BaseLevel_X" and has the name X 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 has to introspect the base object to obtain parameters such as the name of the invoked method, the value and type of the variable, and the like. 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 to allow the meta-object to access 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-objects to access introspection and alteration methods at the base level in the generated source code.

C. Coherent Runtime Adaptation Management According to the Present Invention In the present invention, it is advantageous to adjust the adaptability of multiple objects of an 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) Appropriate adaptive processing is started depending on the received event, and instability and inconsistency (i
An adaptation manager that controls the adaptations made to avoid nconsistency).

Adaptation Events and 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, in a video conferencing application having an adaptive video channel object and an adaptive audio channel object, it is desirable to adapt the audio channel object after adapting the video 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" adaptation processes that respond to these events in the application. In the present invention, adaptation events are generated externally by various elements such as a system statistics server, 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. When 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 adaptive processing is realized by a library designer and an application designer in order to control the adaptability of the adaptive 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 related to 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 prohibit 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 adaptation objects in the application.
r ”and“ print_jp ”to control the adaptation manager.

Executing Adaptation Using the DART Manager API For example, adaptation in DART is a simple C function using the adaptation manager to search for a particular instance of a class (the class associated with the adaptation). 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, in order to simplify the development process of adaptive software, an application programming interface (hereinafter, referred to as “application programming interface”) of a set of adaptation managers is described.
It is called 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. Adaptation manager API according to the invention
Table 5 shows a specific example.

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 * Ge tSelectors (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 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 the 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. Building Distributed Applications Using DART While the adaptation mechanism is provided by the core DART platform, the adaptation library provides other services that handle distribution, such as adaptation classes, meta-level objects, and adaptation processing. . 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 consists of two independent layers. The lower layer handles the communication and broadcasts a light adaptive group protocol (multicas) that is shared by several replicated objects.
t) Use the protocol. The upper layer handles the duplication and controls the transmission of updates, the management of consistency and the updating of local duplicates. 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 of data, such as new object states, 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 sending 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 duplicate meta-level objects as the default metaspace for duplicating 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 "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. Replica 82 is similar to 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
A local special method generated by the RT compiler is 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. In accordance with one embodiment of the present invention, a distributed application includes an adaptive process that changes the metaspace and includes a passive replication meta-object upon detecting a sudden change in network bandwidth or usage. be able to.
In the present invention, the adaptation is automatic and the application designer does not need to write code to handle the adaptation.
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 processing, 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. the introspection and alteration methods at the base level, introduces basic functions which 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-described 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 the 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]

Reference Signs List 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, 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 United States of America 95134-1901 Santa Clara Zankar Road 3300 Sony USR Distributed System Laboratory F-term (reference) 5B045 GG01 5B076 DA00

Claims (28)

[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,
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, a new object Extending itself to register with the adaptation manager; and inserting a second set of instructions to delete the selector into the application source file when the first instance of the adaptation class is finished. Extending an adaptive class destructor including the adaptive software method. A method for developing an adaptive software application program for a distributed adaptive runtime platform. 2. The method of claim 1, further comprising the step of inserting a third instruction set for registering a first instance of the adaptation class in the adaptation manager into the application source file at the time of materialization. Changing the selector in accordance with a change in the execution environment of the adaptive software application program at the time.
2. The method according to claim 1, wherein the adaptability of the instance of the application is controlled. 3. The method of claim 1, wherein the adaptation class includes a reflection software method, and 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 instruction set of the adaptive class into the application source file; and a fifth instruction set for removing the reflector when the second instance of the adaptive class terminates. Extending the destructor of the adaptive class including 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 with the adaptation manager into the application source file at the time of reification. 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 1, further comprising the step of inserting an eighth instruction set into the application source file for automatically generating a metal 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. A method for generating a replication protocol having a lower layer for performing communication between a plurality of replication objects and an upper layer for performing a plurality of replication protocols including passive replication, active replication, and a master proxy. The method of developing an adaptive software application program for a distributed adaptive runtime platform according to claim 3, comprising: 8. 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 of developing an adaptive software application program for a distributed adaptive runtime platform according to claim 3, comprising: 9. 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. An adaptive software application program development method for a distributed adaptive runtime platform according to claim 8. 10. 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,
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, a new object Means for extending itself to register with the adaptation manager, and by inserting into the application source file a second set of instructions for deleting the selector when the first instance of the adaptation class is terminated. Means for extending an adaptive class destructor including the adaptive software method. 11. The system further comprises 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 the time of execution. 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 10, wherein the adaptability of the instance of is controlled. 12. 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. 13. The method according to claim 13, further comprising: a means for inserting a sixth instruction set for registering an instance of the adaptation class in the adaptation manager into the application source file when the adaptation manager is embodied. 13. The computer device according to claim 12, 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. 14. 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 10, wherein one is selected. 15. The method according to claim 15, further comprising inserting an eighth instruction set into the application source file for automatically generating a metal wrapper for the reflection software method, wherein the meta wrapper is called when the reflection software method is called. 13. The computer device according to claim 12, wherein parameters of the reflection software method are provided in the reflector. 16. A means for generating a replication protocol having a lower layer for communicating between a plurality of replication objects and an upper layer for executing a plurality of replication protocols including passive replication, active replication and a master proxy. 13. The computer device according to claim 12, comprising: 17. The method according to claim 9, further comprising generating an introspection method for causing the meta-object to obtain an internal state of a second instance of the adaptive class.
13. The computer device according to claim 12, further comprising means for inserting said instruction set into said application source file. 18. A means for inserting into the application source file 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 17. 19. A computer device for developing a general-purpose distributed adaptive application, comprising: storage means for storing a software platform for developing the general-purpose distributed adaptive application; and a processor for executing the software platform stored in the storage means. The software platform includes a precompiler for converting source code of an adaptive software application into which a keyword for describing and defining an adaptive class is incorporated into a low-level generated code, and a machine-executable machine for the low-level generated code. The precompiler detects the keyword, and when the keyword indicates that the adaptive class includes an adaptive software method, Inserting a predetermined first set of instructions into the application source file that generates a software selector upon generation of a first instance of the adaptation class allows the constructor of the adaptation class to be created by a new object. The application class is extended by registering with the adaptation manager, and inserting a predetermined second instruction set for deleting the software selector into the application source code when the first instance is completed. A computer device characterized by extending the destructor of (1). 20. The precompiler according to claim 1, wherein said keyword indicates that said adaptation class includes a reflection software method.
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. 20. The computer device according to claim 19, wherein the destructor is extended by inserting a predetermined fourth instruction set for deleting the destructor into the application source code. 21. The computer device of claim 20, further comprising an adaptation manager that controls the adaptability of a number of adaptation objects of the software application program. 22. The precompiler inserts, into the application source file, a fifth instruction set for registering the first instance with the adaptation manager at the time of materialization, wherein the adaptation manager executes the adaptation software at the time of execution. 22. The computer device according to claim 21, wherein adaptability of the first instance is controlled by changing the selector according to a change in an execution environment of an application program. 23. 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. 22. The computer device according to claim 21, wherein adaptability of the second instance is controlled by changing the selector according to a change in an execution environment of an application program. 24. The precompiler inserts a seventh instruction set into the application source code that automatically generates a switching wrapper for the multiple implementations, the switching wrapper comprising: 21. The computer device of claim 20, wherein when called, one of the multiple implementations is selected according to information stored in the selector. 25. 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. 21. The computer device according to claim 20, wherein parameters of the reflection software method are provided in the reflector. 26. The precompiler according to claim 26, further comprising: a replication protocol having a lower layer for performing communication between a plurality of replication objects and an upper layer for performing a plurality of replication protocols including passive replication, active replication, and a master proxy. The computer device according to claim 21, wherein the computer device generates the information. 27. 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 adaptive class. 21. The method according to claim 20, wherein
A computer device according to claim 1. 28. 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. 28. The computer device according to claim 27, wherein: