JPH0991143A - Data processing method and device - Google Patents

Abstract

(57) [Abstract] [PROBLEMS] To simplify the configuration of a client and enable cost reduction. A server 1 and clients 2-1 and 2-2
Are connected via the network 3. The server 1 has an execution environment 22-1, which the clients 2-1 and 2-2 have.
The execution environments 12-1 and 12-2 corresponding to 22-2 are prepared in advance. When the predetermined objects 24-1 and 24-2 are required in the application programs 21-1 and 21-2 of the clients 2-1 and 2-2, the application program 11 of the server 1
The objects 14-1 and 14-2 of -1 and 11-2 are downloaded.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a data processing method and device, and more particularly to a data processing method and device which can simplify the configuration and reduce the cost.

[0002]

2. Description of the Related Art Recently, personal computers have become popular. This personal computer can access a predetermined server via a network to obtain predetermined information.

An application program is required to perform various processes in such a personal computer. Therefore, each user purchases, installs, and uses an application program suitable for the OS of the personal computer.

[0004]

As described above, since different OSs result in different application programs, each user must select and purchase an application program that matches his or her OS. Also,
Even on the side that provides the application program (the side that designs the application program), it is necessary to design and prepare a plurality of application programs (as many as the number of OSs) that perform substantially the same processing, which requires a lot of labor. At the same time, there was a problem that the cost was high.

The same thing occurs in each application program in the same OS. That is, one application program,
Other application programs different from that,
Even if they run on the same OS,
The two application programs have to be designed separately, and as a result, there is a problem that the labor and cost required to provide one application program become high.

The present invention has been made in view of such circumstances, and it is an object of the present invention to provide one application program easily and at low cost.

[0007]

According to the data processing method of the present invention, when the server downloads the application program to the client, it is checked whether or not the client has an execution environment of the application program to be downloaded. The application program is downloaded to the client according to the inspection result.

According to a ninth aspect of the present invention, when the application program is downloaded to the client, the data processing apparatus has an inspection means for inspecting whether the client has an execution environment of the application program to be downloaded, and an inspection result of the inspection means. And downloading means for downloading the application program to the client.

According to a tenth aspect of the present invention, when a data processing apparatus downloads an application program from a server, a notification means for giving a notification about an execution environment of the application program to be downloaded, and an application program from the server corresponding to the notification of the notification means. And a download means for downloading.

The data processing apparatus according to claim 11 interprets and executes the application program converted into the intermediate code, and a first execution means and a binary for dynamically compiling the intermediate code to generate a binary code. It is characterized by comprising code generation means and second execution means for executing binary code and system objects.

A data processing method according to a fifteenth aspect is a first method for interpreting and executing an application program converted into intermediate code, and a method for dynamically compiling the intermediate code and executing the generated binary code. The second method is to execute the application program.

In the data processing method according to the first aspect, when the application program is downloaded to the client, it is inspected between the client and the server whether or not the client has an execution environment of the application program to be downloaded, and the inspection is performed. Download the application program to the client according to the result.

In the data processing device according to the ninth aspect, when the checking means downloads the application program to the client, the checking means checks whether or not the client has an execution environment of the application program to be downloaded, and the downloading means , The application program is downloaded to the client according to the inspection result of the inspection means.

In the data processing device according to the tenth aspect, when the notifying means downloads the application program from the server, the notifying means notifies the execution environment of the application program to be downloaded,
The download means downloads the application program from the server in response to the notification of the notification means.

In the data processing device according to the eleventh aspect, the first executing means interprets and executes the program converted into the intermediate code, and the binary code generating means,
The intermediate code is dynamically compiled to generate a binary code, and the second execution means executes the binary code.
For example, when dynamic compilation is difficult, the intermediate code can be sequentially interpreted and executed.

According to a fifteenth aspect of the present invention, in the data processing method, a first method of interpreting and executing a program converted into intermediate code and a method of dynamically compiling the intermediate code and executing the generated binary code are executed. The second method is to execute the application program. For example, when dynamic compilation is difficult, the intermediate code can be sequentially interpreted and executed.

[0017]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 1 shows an example of system configuration to which the data processing method of the present invention is applied. System is server 1
(Data processing device), client 2 (data processing device), and network 3.

That is, in this embodiment, the server 1 has two application programs, and one application program 11-1 defines an execution environment 12-1 and an application program 11-. 1 has an application program interface (API) 13-1 that constitutes an interface between it and the execution environment 12-1.

The application program 11-1 is
It is composed of a plurality of objects 14-1, and the execution environment 12-1 is also composed of a plurality of objects 15-1.

Similarly, the application program 11
-2 has an execution environment 12-2 that defines the environment and an API 13-2 that functions as an interface between the application program 11-2 and the execution environment 12-2.

This application program 11-2
Also includes a plurality of objects 14-2, and the execution environment 12-2 also includes a plurality of objects 15-2.

Similarly, the client 2 also has two application programs, and one application program 21-1 defines an execution environment 22 that defines the environment.
-1, and an API 23 that is an interface between the application program 21-1 and the execution environment 22-1
One. Application program 21-1
And the execution environment 22-1 each include a plurality of objects 2
It is composed of 4-1 and 25-1.

Similarly, the application program 21
-2 also defines the execution environment 22-2 and the API that define the environment.
23-2 and the application program 21-
2 and the execution environment 22-2 are composed of a plurality of objects 24-2 and 25-2, respectively.

Here, each object is defined as a parallel object that executes processing in parallel with other objects. Since a set of one API is given by one execution environment, a plurality of APIs exist in the server 1 and the client 2.

As shown in FIG. 1 and enlarged in FIG. 2, the application program 11 is composed of a group of a plurality of objects 14. Also, by configuring object 14 as a parallel object,
The application program 11 is processed in parallel, which contributes to improvement in execution speed. Further, since the object 14 is also a unit of replacement, by replacing an object having a bug in operation, an object having a performance problem, or the like with an error-free object, the problem can be solved without recreating the entire application program 11. it can. Further, a new application program can be easily created by using the object 14 as a component and combining objects as components of an existing application program.

Here, the application program is one service unit. For example, an application program that simply displays video data from the server 1, an application program that searches for video data using the VCR function, an application program that selects a service from a menu, an application program for home shopping, a home It is a household account book application program connected to shopping, a tax calculation application program, and the like.

By sharing the object between the application programs, the operability can be made common. For example, the editor for inputting data in the household account book and the data input editor for home shopping can be shared.

Next, a parallel object (concurre
nt object) will be described. The structure of a parallel object is shown in FIG. The object 14, which is a parallel object, has a table 14A of method entries exposed to the outside, a body 14B of the method, a memory area 14C for holding the state of the object, and a single thread 14D for executing the method. There is only one execution context (which may be called a thread) in a concurrent object. Therefore, the parallel object receives one message and, during its processing, does not process the newly arrived message until the current execution is finished.

By arranging only one thread in the object in this way, the following advantages are obtained.

(1) There is no need to worry about synchronization between a plurality of activities. In other words, when shared data exists, it is not necessary to use a semaphore or other instruction for synchronization to order access to the shared data. In other words, sending a message to an object will include its ordering.

(2) Therefore, a program error due to an error in synchronization is prevented, and at the same time, the reusability of the object is increased.

(3) For example, by creating a device driver by this method, it is possible to prevent a synchronization error that often occurs.

(4) Further, since it is possible to prevent the synchronization error due to the replacement of the device driver, the device driver can be safely replaced.

(5) The part of the device driver other than the part that actually controls the hardware can be created independently of the OS. As a result, it becomes possible to commonly develop device drivers, which have conventionally taken a considerable amount of time for development, which leads to a reduction in development period.

(6) The description relating to execution control between objects can be excluded from the description of the application program. For example, in the method using multi-thread (when multiple threads are used), the execution control of the thread needs to be programmed in the application program, and therefore the application program is rewritten when the programming environment of the thread is changed. There is a need. However, when the number of threads is one, it is not necessary to describe this part in the application program, and therefore it is not necessary to rewrite the application program even if the execution control method changes. An optimal execution control method for a concurrent object in its execution environment is provided by the system using the principle of dynamic extension of an object, which will be described later.

(7) Therefore, when writing an application program, it is not necessary to consider parallel processing.
Since a parallel object is a unit of parallel processing, if the parallel object is programmed, the system will automatically perform the optimum execution control for the hardware and the parallel processing will be performed. In the conventional method, the number of processes to be created and the number of threads to be created must be specified at the time of programming, and if this specification does not consider the performance of the hardware, the application program can It will be dedicated to hardware, but according to this method, there is no such thing.

In this system, objects are downloaded as needed. FIG. 4 shows a system example in the case of downloading an object from the server 1 to the clients 2 of a plurality of vendors. On the server 1, client APIs 13 (1
3-1, 13-2) is the execution environment 12 (12-1, 12)
-2) is realized.

The object is sent to the client 2 (2-1,
2-2), the same execution environment 22 (2
2-1 and 22-2) are present, and if they are present, the object is downloaded. If it does not exist, the same execution environment as the execution environment on the server 1 is constructed on the client 2 and then downloaded.

For example, in FIG. 4, the object 14-1 of the application program 11-1 of the server 1
Is downloaded as the object 24-1 of the application program 21-1 of the client 2-1, it corresponds to the execution environment 22-1 of the client 2-1 and the object 15-1A of the execution environment 12-1 of the server 1. When the object 25-1A is necessary, for example, the object 15-1B (inspection means) of the execution environment 12-1 is the object 25-1 of the execution environment 22-1.
Feature structure (described later) in B (notification means)
To inquire. In response to the answer, the object 15-1C (download means) of the execution environment 12-1 and the object 25-1C (download means) of the execution environment 22-1 are the objects 15-1A of the execution environment 12-1. 15-1B and 15-1B are downloaded as objects 25-1A and 25-1B of the execution environment 22-1.

In the conventional method, the object to be downloaded needs to be created in accordance with the API of the client. For example, when the client is a UNIX system, it is necessary to use the same UNIX system on the server or build some cross development environment to create an object. If the server and client must have the same execution environment, the client device generally needs to have expensive computational resources. For example, it is necessary to provide more memory as compared with the case where a dedicated execution environment is provided. In addition, in order to guarantee sufficient execution speed, a high-speed CPU (Centra
l Processing Unit). This leads to an increase in the cost of the device.

On the other hand, this system solves this problem by downloading the application as well as its execution environment. That is, by constructing only the execution environment 22 currently required by the client 2 in the client 2, it becomes unnecessary to prepare unnecessary resources in the client 2.
For example, if client 2 does not need 3D graphics, its library is not needed.

Further, the client 2 uses the VOD (Video)
o On Demand)
By temporarily deleting a service for interacting with the user (a service that is unnecessary when watching a movie) from the client, the corresponding computing resource can be allocated to other work. For example, the resource can be used for a buffer for prefetching video data from the server 1. The services for interaction are
When it becomes necessary, it is downloaded from the server 1.

The following objects can be considered as objects downloaded by this system.

(1) All application programs

(2) A device driver group (for example, M
(PEG driver, ATM driver, image control driver, etc.)

(3) Objects that provide system services to application programs (for example, VCR command management, stream management, real-time scheduler, memory management, window management, download control, communication protocol management, execution management, etc.)

By combining these, an optimum execution environment for the application program is constructed on the client.

The server 1 is a device for transmitting video data and application programs, and a device for transmitting information to the client 2 through the network 3. On the other hand, the client 2 is a device that processes information from the server 1, and does not need to be always connected to the network 3. Since the execution environment can be provided for each application program, an optimum execution environment can be prepared for each application program.

In the conventional method, it was necessary to estimate the characteristics of the application in advance when constructing the system. For example, when an application program needs to handle video data, it must have a system service therefor, for example, a user interface such as a VCR for handling real-time scheduling or video data. Also, if the application uses 3D graphics, it is necessary to have a library for it. Therefore, the system tended to be bloated. UNIX and Windows (trademark)
This is a typical example, and the amount of memory required by the system increased with each version. The present system solves this problem of the conventional system by providing only the minimum necessary functions for executing the application.

By configuring the application program 11 as a group of a plurality of objects, and implementing the object as a parallel object, parallel execution can be performed in object units, and the objects are downloaded at the same time as the execution of the application program. can do. At this time,
By incrementally downloading the objects required to execute the application program, as shown in, it is possible to hide the time required to load a single application program from the user.

For example, as shown in FIG. 5, the object 14-1 of the application program 11 of the server 1
-1 to 14-1-11 need to be downloaded as the objects 24-1-1 to 24-1-11 of the application program 21 of the client 2, instead of randomly downloading each object, the application program In executing step 21, the first required objects 14-1-1 to 14-1-3 are replaced with objects 24-1-1 to 24--
Download as 1-3 first.

For the time being, the application program 21 can be activated if these three objects exist, and therefore starts its processing. Then, while the processing is being executed, the remaining objects 14-1
-4 to 14-1-11 are sequentially downloaded in the second to fourth downloads as the objects 24-1-4 to 24-1-11 of the application program 21. Also in the second to fourth downloads, the objects that are required first in processing are downloaded in order.

The user uses the application program 2
1 objects 24-1-1 to 24-1-3 have been downloaded, and the processing of the application program 21 has already started at the time the processing is started, so that it is as if all the objects have been downloaded. Can be recognized. That is,
The user will only be aware of the time required to download three objects, which is less than the time required to download eleven objects. In other words, the time for downloading the eight objects can be substantially hidden (not made conscious) from the user.

This also applies to the case where the execution environment 22 described with reference to FIG. 4 (also described later with reference to FIG. 10) is constructed on the client 2. In this case, among the objects constituting the execution environment 22, only the objects necessary for executing the application program are downloaded first, so that the time for downloading all the objects in the execution environment can be hidden from the user. . This technique can also be applied to boot the system.

Here, the incremental download means that an application program or an execution environment is not downloaded at a time, but an object unit constituting the application program or a part thereof is downloaded as needed. In the case of downloading an application program in the conventional personal computer communication, the compressed application program is downloaded all at once, and the application program cannot be used unless the download is completed. Further, for example, in the conventional system boot, the entire system is read into the memory and then booted.
In the case of a UNIX diskless workstation, the system is started after all the OSs are read from the server into the memory, and therefore the system cannot be used until the reading is completed. However, with an incremental download, that is no longer the case.

This method has the following effects when applied to STB (Set Top Box) as the server 1 and the client 2. First, the STB is ready to use as soon as it is turned on. There is no need to irritate and wait for the system to start up, unlike the current personal computers. Since STB has a strong character as a household electric appliance, it is not preferable to make the user wait until the system starts up.

When the STB is powered on, it first tries to download the required objects and start executing. The user wait time is only the initial download time of this object. Since the download time of a typical object is a few milliseconds to tens of milliseconds, by providing an appropriate user interface, this time is sufficiently negligible to the user. After that, the necessary objects are downloaded in parallel with the system startup process as the system startup process progresses.

From the viewpoint of cost, the STB is
Since abundant computational resources such as servers are not prepared, there are restrictions when executing multiple applications at the same time. For example, when considering to watch one movie by selecting the VOD service by the navigation application, when the movie watching starts,
The resources (memory) occupied by the navigation application can be released and used for the movie watching application. Then, when the navigation application becomes necessary again, the resource (object managing memory) is downloaded.

Here, the "time when it becomes necessary" is the time when some message is sent to the object. That is, when the first downloaded object sends a message to another object, the received object is downloaded. By using the object dependency and reference relationship, the object to send the next message can be downloaded in advance. By performing this in parallel with the execution of the application, it is possible to reduce the delay due to download during message communication.
Thereby, the effectiveness of incremental downloading can be improved.

The execution environments 12 and 22 are also a collection of objects 15 and 25, and can be operated in the same manner as the objects 14 and 24 of the application programs 11 and 21.
It is possible to prepare a meta-object for controlling the download sequence specialized for the object as one of the objects 15 and 25 (for example, the object 25-1C in FIG. 4 is the meta-object). This makes it possible to specify the download order of the objects used by the object, which is suitable for a specific application, and minimize the user waiting time due to the incremental downloading.

The function of downloading an object from the server 1 to the client 2, the function of checking the compatibility of the execution environment of the object with it, and the function of constructing the execution environment are important in realizing this system. This is a function that all devices (clients 2) configuring this system should have. In this specification, this function is called a meta standard. By this meta-standard, the API of the execution environment such as the OS can be freely expanded, and with the minimum standardization and its expansion, it becomes possible to support all types of applications in the future.

For example, in the system shown in FIG. 6, each server 1-1, 1-2 and each client 2-1 and 2-2 are running an OS having a unique API. That is, in the client 2-1, the API 23-1 (API # 1) for the application program 21-1 is configured corresponding to the execution environment 22-1. In the client 2-2, the execution environment 22-2
A for application program 21-2
PI23-2 (API # 3) is formed.

Therefore, these clients 2-1 and
An API corresponding to these APIs is prepared in advance in the server that downloads the program to 2-2. In this embodiment, in the server 1-1,
Application program 1 by the execution environment 12-1
An API 13-1 for 1-1 is formed, and this API 13-1 is an API in the client 2-1.
23-1 (API # 1) corresponding API (API #
1).

Similarly, in the server 1-2, the execution environment 1
An API 13-3 (API # 3) corresponding to the application program 11-3 is formed by 2-3, and this API 13-3 is the API of the client 2-2.
23-2 (API # 3).

Therefore, in the servers 1-1 and 1-2 and the clients 2-1 and 2-2, objects 15-1A to 15-1 are provided as objects corresponding to the meta standard.
C, 15-3A to 15-3C, 25-1A to 25-
1C and 25-2A to 25-2C are provided. As a result, for the client 2-1 or 2-2,
The required objects can be appropriately downloaded from the server 1-1 or 1-2 according to the meta-standard protocol.

One OS for each client
It has been a tendency in this field to standardize to the past. However, such a meta-standard is defined, and only the server side has the API of each client.
By providing an API corresponding to, there is no need to determine a standard.

By not defining one OS standard, it becomes possible to configure applications, including applications, that realize system services, independently of the OS. That is, software written for one execution environment may be automatically reconfigured for another execution environment by migration. This function does not exist in conventional systems. For example, UNI
Software written for X is on Windows,
It will not work unless rewritten. To realize this function with application-level software, it is necessary to introduce software that absorbs OS dependency. However, the independence of the OS of an object that realizes a system service, such as a device driver, becomes possible by using this method.

As described above, when the object is downloaded, the object of the client 2 becomes
As shown in FIG. 7, it can be changed dynamically. That is, the existing object is deleted from the client and the new object is downloaded from the server.

For example, in the embodiment shown in FIG. 7, the object 24A in the application program 21 of the client 2 is no longer necessary, so it is deleted. Then, the newly required object 14A is downloaded from the server 1 to the client 2.

This enables the following.

(1) Software can be updated. For example, when a bug is found in the hardware control software, the object is deleted and replaced with a new object. Home appliances are used by non-computer specialists, non-computer consumers, so updating software with an installer, such as found on some computers, is not appropriate.

(2) The product cycle can be lengthened. For example, a television receiver undergoes a model change every year, but general consumers do not buy a new television receiver every year. However, with this system, all the software problems can be provided to the user with the latest functions, so that the model change due to the function expansion of the software can be eliminated. This is also the case for STB.

(3) It is possible to cope with changes in user interface preferences. For example, provide a friendly menu format to a user who has started using the device for the first time, but as the user becomes more familiar with how to use the device, change to a direct operation user interface that enables direct and desired operation. You can In this case as well, it is possible to provide the client side with a user interface according to the user's skill level at that time, instead of providing both procedures on the client side. This makes it possible to effectively use limited client resources.

If the object is downloaded, the object of the client 2 can be dynamically expanded as shown in FIG. In the embodiment shown in FIG. 8, in order to receive a new service for the object 24-1B of the application program 21-1 in the client 2, the execution environment 22-
2 has been generated. Then, necessary objects 25-1A and 25-1B from the execution environment 22-1 are
-2, so that objects 25-2A and 25-2B become objects (-2). Further necessary other objects 25-1C and 25-1D are also included in the execution environment 22-
Migrated to 2.

The application program 21-
2, the object 24-1B of the application program 21-1 is migrated to become the object 24-2B.

In this way, for example, when extension of real-time scheduling becomes necessary, a new execution environment for that is created in the client, and necessary objects are moved to the new environment. The object does not need to be modified and the object can be serviced for real-time scheduling.

As a result, the following effects can be obtained.

(1) Since the new function can be dealt with without changing the object of the application program, the life of the application program is extended and the reusability is increased. With traditional methods,
The change of the execution environment means that the application program is rewritten because the application program includes the dependent code for the execution environment.

(2) In the case of an application program for an embedded device, the high-performance control software part of the device, including the user interface, is the part that should be reused unless the model changes significantly, and the existing code It is a part that wants to shorten the development period only by extending the function by using, but if this part contains the code that depends on the execution environment, the work for reuse becomes complicated. The conventional method has no strategy for this part, but this method can automate or minimize this work.

The present system can be specifically applied as follows.

(1) When the reliability of the application is low, it is possible to prevent the entire system from being stopped by downloading the memory protection function.

(2) The service provider can change the provided service for each STB vendor. For example,
The service provider that provides the movie of the movie company A can change the image quality between the STB of company B and the STB of company C that receive the movie.

(3) The processing method of the system is changed according to the compression method of the A / V data sent to the STB and the user's preference for image quality. For example, since the method of adjusting the image quality is different between MPEG data and JPEG data, it is necessary to change the processing method of the system, but in this system, the processing method can be dynamically selected according to the data format.

As described above, most of the functions of the system can be downloaded from the server 1. Therefore, it is not necessary to give the client 2 various functions in advance, and only the minimum functions are required. FIG. 9 shows the minimum functions of the client 2 in this system.
That is, the client 2 includes an execution environment 22-1 for a device driver, an execution environment 22-2 for a system object, and an execution environment 22-3 for an execution environment.
Is formed at a minimum.

A device driver that needs to exist in advance is an input drive that processes an input.
r, a timer driver that manages time, and screen driver drivers 24-1A, 24-1B, and 24-1C that control display, and a system object is an input hand that manages input.
ler, boot protocol that manages startup,
It is each object 24-2A, 24-2B, 24-2C of memory manager which manages memory.
Higher-performance device drivers and system objects are downloaded from the server 1.

FIG. 10 shows an embodiment in which a client environment suitable for an application program (video, game, shopping, etc.) sent by a server is dynamically constructed. In FIG. 10, in order to download the shopping application program 11-2 from the server 1, the shopping execution environment 22-4 is configured in the client 2-2. Further, when the client 2-2 switches the application program from the shopping application program to the movie application program, the execution environment 22-3 of the movie application program 21-3 is changed to the client 2-.
2, the movie application program 11-1 is downloaded from the server 1.

For example, the following processing can be considered.

(1) When the user selects a movie At this time, the navigation application 11-3 downloads to the execution environment 22-1 of the client 2-1 so that a desired movie can be selected. As a necessary environment for the above, an object 15-3 such as window management and user input management is downloaded as an object 25-1.

(2) When the user is watching a movie At this time, from the execution process 12-1 of the server 1-1, the video stream management, data prefetch buffer management, VC
The object 15-1 such as the R function is downloaded as the object 25-3 into the execution environment 22-3 of the client 2-2, for example.

As described above, in order to realize the execution environment of the client by downloading, in this system, the feature structure (feature) shown in FIG. 11 is used.
structure) is introduced. When the object is downloaded from the server 1 to the client 2, this feature structure is inspected and the necessary execution environment is configured in the download destination.

That is, the server 1 has a possibility of object migration with the client 2 in the first phase (negotiation phase) between the meta-object space on the server 1 side and the meta-object space on the client 2 side. Negotiate about. And the second phase (movement phase)
At, the object is actually transferred.

Object migration is a meta-level process that transfers internal information about an object and, if necessary, the computational resources used by the object associated with it. The internal information of an object is represented by a meta-level object called a descriptor. The descriptor actually holds the name of the meta-object that manages the object. A general descriptor is the name of the meta-object that manages the memory segment of the object, the name of the meta-object (scheduler) that controls the execution of two or more objects, and the meta that manages the naming of the object. Holds the name of the object, etc.

In the first phase (negotiation phase), the possibility of movement of the object is checked. That is, depending on the meta-object space, object migration may not be desirable. For example, when the meta-object space that manages the device driver moves an object (device driver), if the hardware device does not actually exist on the client 2 side, it does not make sense to move the object. It will disappear. A meta-object that manages a memory segment of an object using the virtual memory management mechanism cannot manage the memory segment even if it is moved unless the virtual memory management mechanism exists at the destination. . Therefore, the following methods are prepared in the migration protocol.

Feature * Descripto
r :: CanSpeak (Feature * pFea
true)

This method is for the descriptor in the meta-object space on the client 2 side,
Perform a CanSpeak operation.

At this time, the feature structure is passed as an argument, and as a result, the client 2 returns to the server 1 a feature structure that it (client 2) can accept. On the server 1 side,
By inspecting the feature structure returned from the client 2 side, it is possible to know the compatibility of the meta object space.

Compatibility is classified into three categories: fully compatible, semi-compatible, and incompatible.

Fully compatible means that the object can continue to run completely after the move. Semi-compatible means that some restrictions are placed on the execution of objects after they have been moved. And incompatibility means that the object cannot continue execution after the move.

In case of incompatibility, object migration is not performed. In the case of semi-compatibility, the user decides whether to migrate or not. In practice, an exception is returned to the user, so the exception handling routine makes the migration decision. In the case of complete compatibility or in the case of semi-compatibility, when object migration is performed, migration is performed according to the contents of the previously returned feature structure.

Prior to the negotiation phase, an empty description is created by the following operation.
or is generated in the meta-object space on the client 2 side.

Descriptor :: Descriptor ()

The previous CanSpeak method uses this d
Sent to the escriptor. At this time, required meta-objects are generated based on the feature structure information, references are generated, and necessary information is registered.

The process at the meta level in the second phase is the movement or transfer of the meta object corresponding to the transfer object. Here, the movement of the meta-object means that the meta-object is the client 2
Side meta-object space, that is, it becomes referred to from a descriptor, and the transfer of the meta-object means that the meta-object in the meta-object space on the client 2 side (this is (referenced by the descriptor), the data in the meta-object is sent as a message.

The actual operations for moving and transferring meta-objects make use of the feature structure obtained by the negotiation phase,
This second phase (movement phase) is executed.

The actual movement and transfer of meta-objects in the move phase is triggered by the following methods.

Descriptor & Descript
tor :: operator = (Descriptor
& Source)

The Descriptor class is an abstract class and defines a common protocol for moving and transferring meta objects. The contents of the descriptor referred to by the source are copied to this descriptor.

The actual procedure is defined as a subclass of the Descriptor class.

The following methods are related to meta-object transfer. These protocols are mainly m
igrator (included in the meta-object space,
Used by the meta-object responsible for object migration).・ Canonical Context & Context
t :: asCanonical () Converts a machine-dependent Context structure to a machine-independent format. This protocol is based on the feature st
It is executed when the direct conversion of Context is impossible by the structure.・ Context & Context :: operat
or = (Context & source) Context & Context :: operat
or = (Canonical Context & sou
rce) current (referenced by this) context
Initialized with the Context referenced by ce.・ Canonical Segment & Segmen
t :: asCanonical () Converts a machine-dependent Segment structure into a machine-independent format. This protocol is based on the feature st
It is executed when the direct conversion of Context is impossible by the structure.・ Segment & Segment :: operat
or = (Segment & source) -Segment & Segment :: operat
or = (CanonicalSegment & sou
rce) current this (referenced) Segment by sou
Initialize with Segment referenced by rce and copy the required memory area.

FIG. 11 shows the structure of the feature structure. As shown in the figure, the object de
description and environnem des des
The description pointer is described in the entry.

The structure pointed to by the object description pointer has an object
ct name is described, and further, environm
A structure pointer that is the same as the structure pointed to by the ent description pointer is described. And further, the resource requirement of this object.
of this object) is described.

Also, the environment desc
An environment name is described in the structure pointed by the pointer of the ripion, and further, resource information of the client hardware (resource information of).
client hardware), resource requirements of this execution environment
of this environment, and a list of meta-objects that make up this execution environment (l
ist of metaobjects consti
toning environment) is described.

Specific examples of the contents of the feature structure are as follows.

(1) Information about object Real-time property Required processor amount

(2) Information on meta-object Hardware meta-object * Processor type * Data representation format Segment meta-object * Size * Possibility of expansion / reduction * Management policy * Layout context meta-object * Register information * Temporary variable amount * Processor status Mailer meta object * Message queue length * Number of unprocessed messages * Necessity of external mailer * Message transfer method External mailer meta object * Message queue length * Number of unprocessed messages * Protocol scheduler meta object * Object status * Scheduling policy Depends Managed meta-object * Number of external names owned

As described above, if each client has a different OS, the OS of each client is determined from this feature structure, and the server will download the object corresponding to that OS.

FIG. 12 shows an example of the configuration of the Apertos (trademark) system to which the data processing system of the present invention is applied. In this Apertos system, A
pertos Micro Virtual Mach
ine (MVM) 31a (first execution means) is Ape
rtos Micro Kernel (MK) 31b
(Second Execution Means) and constitutes the core 31 of the Apertos system. MVM that constitutes the nucleus 31
31a interprets and executes an intermediate code (I-code), which will be described later, and uses the function of the MK31b to execute the p
The personality object (system object) is called.

The parts other than the core 31 shown in FIG. 12 can be downloaded from the server 1, for example, by the method described above.

This system uses the I-cod as required.
Dynamically compile e into native code (binary code, machine code). In addition,
The object compiled in vecode is executed, but in that case, it is Per by the function of MK31b.
The sonality object 33 (binary code generation means) is called, and the application (Appli
services).

MVM3 constituting the nucleus 31 shown in FIG.
1a and MK31b have a device driver object (Device drivers) 32 and a personality object (Persona) outside them.
little component objects) 33
Surrounded by, and further outside, a class system for application programming (Cl
ass Libraries 34 are prepared,
Furthermore, an application 35 is prepared on the outside thereof.

Personality object 33
Depending on the layer, the Apertos system has various operating systems (OS) and Virtual Mach.
It is possible to provide ine (virtual computer). For example, the execution of the Java program is executed by the Personality object for the Java program by j
This is performed by executing the Java bytecode which is an intermediate code obtained by compiling the ava program.

The Apertos system is an advanced por
In order to implement the
It compiles to code (intermediate code) and manages object methods. However, I-cod
The e is not designed on the premise of interpretation execution (execution while interpreting a program), but is designed to be compiled into a native code by a dynamic compiler. However, due to various restrictions, when the dynamic compilation is difficult, the MVM 31a uses the I-co
Interpret and execute de.

However, in most cases, I-co
The de is compiled into a native code and directly executed by the CPU configuring the system. Therefore, there is almost no lack of real-time performance or sacrifice of processing speed due to execution by the Virtual Machine.

The above I-code is an advanced Inter-
In order to realize the Operationality, as will be described later with reference to FIG. 22, it is composed of two instruction sets (OP_M, OP_R) having a sufficiently high degree of abstraction, and its semantics (semantic structure) are the interface of the MK31b. It is strongly associated. That is, the instruction set is strongly influenced by the structure of the Apertos system shown in FIG. As a result, in the Apertos system, it is assumed that the native code is used, but the high portability and integrity
r-operability can be realized.

Next, the specifications of the MVM 31a and MK 31b will be described. First, the data structure assumed by the MVM 31a and the I-code format are defined.

FIG. 13 shows the logical structure of the MVM 31a and MK 31b shown in FIG. Basically, both logical structures are the same, and active context4
1, message frame 42, and exec
The MVM 31a supports the execution by the I-code, and the MK 31b supports the execution by the native code.

In FIG. 13, active cont
ext41 points to the currently executing Context (described later with reference to FIG. 14), and the message f
The frame 42 indicates the message body for the MVM 31a and MK 31b that compose the nucleus 31.

In the case of MK31b, the location where the message body exists depends on the mounting method, and may be allocated to the memory as a stack frame, or the heap (hea).
p) in some cases. Also some C
PU registers may also be allocated. On the other hand, M
In the case of the VM 31a, the message frame will point to the operand following the instruction code. Depending on the implementation, other internal registers may be needed, but those registers are independent of this specification.

In FIG. 13, execution e
ngine43 is I-code and native
Execute code. Also, the execu of MVM31a
to the function engine43.
The objects 44 are included and are shown in FIG.
Is a code for processing a primitive object described later with reference to.

FIG. 14 shows Context and Descri.
The logical structure of ptor is shown. The Context structure 51 indicating one execution state of the program is an object
It has fields such as ct, class, method, and meta, of which, in the method, icon
The e and minfo fields are further provided.
The Context structure 51 holds the state of the MVM 31a, corresponds to the register of the CPU, and is completely independent of the memory management and the communication method between programs.

The Context structure 51 is the Context
It is an xt primitive object, and its fields are linked to predetermined information, as will be described later with reference to FIG. Further, the Context structure 51 is deeply dependent on the mounting of the nucleus 31 (MVM 31a and MK 31b), but FIG. 14 mainly shows a non-dependent part.

The important field in this Context structure 51 is the meta field, Des
It points to the descriptor structure 52. Descri
The entries of the ptor structure 52 are #tag, cont.
ext and selector are three sets,
By this Descriptor structure 52, Per
The API (application programming interface) of the sonality object 33 is determined. #Tag is the API name, context and se
The address of each API is represented by "lector".

FIG. 15 shows the overall structure of the MVM 31a. Basically all the necessary information is Context
The t structure 51 can be referred to by following a link. That is, the Context structure 51 is linked to the object 61,
The object 61 is a link (class pointer) to the class corresponding to the object 61 and an instance area (object dependent field).
d). What information is stored in the instance area or its layout depends on the implementation of the object.

The class 62 mainly holds a method. The class 62 is its name (class na
me), its implementation-dependent part (class depth)
end field), and I-method
Link table to structure 63 (method tab)
le). I-method structure 63
Is a Block primitive object and includes a header (Header), an I-code unit, and a variable table (Variable table). ma
gic # is a management number (ID) of the MVM 31a.
Basically, the operand of the I-code instruction refers to the target object via this variable table entry.

In FIG. 15, the gray portion (Cont.
ext51, I-method63) is a part that depends on the MVM 31a, and is a structure required when the MVM 31a interprets and executes the I-code.

FIG. 16 is a diagram showing a structure that is linked from the Context structure 51 as a center. The object field of the Context structure 51 points to the object 61, and the class field is the class dependency of the class 62.
nt field. The method field points to I-method 63, and
The code in the hod field is I-method6.
3 I-code. icode corresponds to a program counter and indicates a program that is being executed. m
The vtable of the method field is I-meth.
It refers to the variable table of od63.

The temporary field indicates the temporary data storage area, and the meta field indicates the descriptor 52 as described above. Also, the class pointer of the object 61
Refers to class62, and the meth of class62
The odd table indicates the I-method 63.

A variable table entry is a combination of type and value, and value depends on type.

The MVM 31a is adapted to process the type shown in FIG. 17, and the type is T_PRIM.
When ITIVE, the value field refers to the primitive object. In this case, in the value column, for example, <P_INTEGER, immediate>, <
P_STRING, address to help>
<P_CLASS, P_ as shown in FIG.
A set of BODY> is stored. FIG. 18 shows a list of primitive objects and their interface names. 19 to 21 show the interface of the primitive object shown in FIG.
e Definition Language (ID
The example described by the L) method is shown. The IDL method is described in "CORBA V2.0, July 199".
5, P3-1 to 3-36 ".

In FIG. 17, the type is T_P.
When OINTER, I to refer to the object
D is stored in the value column. This ID is the only value in the system whose location is independent, and Persona
The location of the object corresponding to the ID is specified by the light object 33.

In FIG. 22, the MVM 31a interprets and executes 2
Shows two instruction sets. The instruction set OP_M is
In FIG. 12, the instructions are from the outside to the inside, and the instruction set OP_R is an instruction to return from the inside to the outside.

That is, the operation indicated by the first operand is executed by the instruction set OP_M.
This operation is processed by the Personality object 33 or the primitive object. The compiler generates an I-code so that some processing is performed by the primitive object in order to execute the application 35 more efficiently. Thereby, for example, the integer arithmetic operation is processed by the primitive object at the head of FIG.

Next, the interface of MK31b is defined. FIG. 23 shows the interface of the microkernel (MK) 31b. MVM31a and MK31b
The logical structure of MK is similar to that shown in FIG.
31b is the instruction set OP_M and O shown in FIG.
Process P_R as a system call.

For example, the client 2 (2-1, FIG. 4) shown in FIG.
2-2) can be applied. Then, by downloading from the server 1 any one of those other than the core 31 shown in FIG. 12, an optimum execution environment for executing a predetermined application can be built on the client 2.

As described above, the following objects can be considered as the objects to be downloaded here.

(1) All application programs

(2) Device driver group (for example, M
(PEG driver, ATM driver, image control driver, etc.)

(3) Object group (per) that provides system services to application programs
Sonarity object) (for example, VCR command management, stream management, real-time scheduler, memory management, window management, download control, communication protocol management, execution management, etc.)

By combining these, an optimum execution environment for the application program can be constructed on the client.

For example, when a Java program is to be executed, the personality object 33 for Java and the Java program (application) are used.
35 from the server 1. This perso
Due to the nality object 33, the
The system is Java Virtual Machine
e can be provided. Downloaded jav
The a program is once Java by the compiler.
compiled into intermediate code called tecode,
It is executed by the above Java Virtual Machine. Alternatively, as described above, native
It is also possible to execute it after compiling it into code.

In the above embodiments, the predetermined object is downloaded from the server to the client. However, the object is downloaded from the predetermined client to the predetermined server, or the objects are downloaded between the servers or between the clients. The present invention can also be applied to such cases.

Further, in the above embodiment, I-cod
Although e is composed of two instructions, the present invention is not limited to this.

[0153]

As described above, according to the data processing method of the first aspect and the data processing apparatus of the ninth aspect, it is checked whether or not the client has an execution environment of the application program downloaded, and the check is performed. Since the application program is downloaded to the client according to the result, the client configuration can be simplified and the cost can be reduced, and the application program can be provided at low cost.

According to the data processing device of the tenth aspect, the application program to be downloaded is notified to the server regarding the execution environment, and the application program is downloaded from the server in response to the notification. It is possible to realize a low-cost device having a simple structure. Further, the application program can be provided at low cost.

According to the data processing device of the eleventh aspect and the data processing method of the fifteenth aspect, the application program converted into the intermediate code is interpreted and executed, or the intermediate code is dynamically executed. The application program is executed by compiling to and executing the generated binary code.
If dynamic compilation is difficult, the intermediate code can be sequentially interpreted and executed. In addition, a portable application can be constructed by making the intermediate code a simple structure.

[Brief description of drawings]

FIG. 1 is a diagram showing a configuration example of a system to which a data processing method of the present invention is applied.

FIG. 2 is a diagram showing a configuration of an application program.

FIG. 3 is a diagram showing a configuration of a parallel object.

FIG. 4 is a diagram illustrating downloading of objects from a server to clients of multiple vendors.

FIG. 5 is a diagram illustrating incremental download.

FIG. 6 is a diagram illustrating a meta standard.

FIG. 7 is a diagram illustrating dynamic change of an object.

FIG. 8 is a diagram illustrating dynamic extension of an object.

FIG. 9 is a diagram illustrating a minimum function of a client.

FIG. 10 is a diagram illustrating construction of a client environment suitable for an application and its dynamic reconfiguration.

FIG. 11 is a diagram illustrating a configuration of a feature structure.

FIG. 12 is an Aper to which the data processing device of the present invention is applied.
It is a figure which shows the structural example of a tos system.

FIG. 13 is a diagram showing a logical structure of MVM and MK.

FIG. 14 is a diagram showing a logical structure of Context and Descriptor.

FIG. 15 is a diagram showing an overall structure of an MVM.

FIG. 16 is a diagram showing a Context and a data structure around it.

FIG. 17: t of a variable table entry
It is a figure which shows ype.

FIG. 18 is a diagram showing a list of primitive objects and their interface names.

FIG. 19 is a diagram showing an interface of a primitive object.

FIG. 20 is a diagram showing an interface of a primitive object.

FIG. 21 is a diagram showing an interface of a primitive object.

FIG. 22 is a diagram showing an I-code instruction set.

FIG. 23 is a diagram showing an interface of MK.

[Explanation of symbols]

1 server, 2 clients, 3 networks, 1
1 application program, 12 execution environment, 1
3 application program interface, 1
4, 15 object, 21 application program, 22 execution environment, 23 application program interface, 31 kernel, 31a MVM, 31
b MK, 32 Device drivers, 33
Personality component ob
ject, 34 Class libraries, 3
5 Applications, 41 active
context, 42 message frame,
43 execution engine, 44 pri
mimitive objects, 51 context
t, 52 Descriptor, 61 objec
t, 62 class, 63 I-method

Claims (15)

[Claims] 1. An application program composed of a plurality of objects, an execution environment composed of a plurality of objects that defines the operation of the application program, and an interface between the application program and the execution environment. A data processing method in a data processing system, comprising: a server including an application program interface; and a client that downloads the application program from the server, wherein when the server downloads the application program, the client , Whether or not there is an execution environment for the application program to be downloaded, and the application program is checked according to the check result. Data processing method characterized by downloading grams to the client. 2. When the client does not have an execution environment of the application program to be downloaded, the object is downloaded from the server to the client, and the same execution environment as the execution environment of the server is constructed in the client. ,afterwards,
The data processing method according to claim 1, wherein the application program is downloaded from the server to the client. 3. The data processing method according to claim 1, wherein the object of the application program is a parallel object. 4. The data processing method according to claim 1, wherein the server incrementally downloads an object of the execution environment required to execute the application program. 5. The execution environment of the client includes, as a minimum standard function, a download function for downloading an object from the server to the client, a check function for checking compatibility of the execution environment, and the execution function. The data processing method according to claim 2, further comprising a construction function for constructing an environment, and downloading other functions as necessary. 6. The client includes, as a minimum standard function, an execution environment for a device driver, an execution environment for a system object, and an execution environment for an execution environment. The data processing method according to claim 2, wherein the other function is downloaded in response. 7. The device driver according to claim 6, wherein the device driver includes an input driver, a timer driver, and a screen driver, and the system object includes an input handler object, a boot protocol object, and a memory manager object. Data processing method. 8. The server and the client exchange a feature structure including a description describing the object and the execution environment, in order to check compatibility of the execution environment of the client. The data processing method according to claim 1. 9. An application program including a plurality of objects, an execution environment including an operation environment of the application program including a plurality of objects, and an interface between the application program and the execution environment. In the data processing device, which includes an application program interface for allowing a client to download the application program, when the client downloads the application program, it is checked whether the client has an execution environment of the application program to be downloaded. And a download means for downloading the application program to the client corresponding to the inspection result of the inspection means. Data processing apparatus, characterized in that it comprises a de means. 10. An application program including a plurality of objects, an execution environment including an operation environment of the application program including a plurality of objects, and an interface between the application program and the execution environment. A data processing device that downloads an application program from a server, and a notification unit that notifies the execution environment of the application program to be downloaded when the application program is downloaded from the server; And a download means for downloading the application program from the server in response to the notification of Apparatus. 11. A data processing device comprising an application program composed of a plurality of objects and a system object composed of a plurality of objects and providing an execution environment for the application program, wherein the data is converted into intermediate code. First executing means for interpreting and executing an application program; binary code generating means for dynamically compiling the intermediate code to generate a binary code; and second executing means for executing the binary code and the system object And a data processing device. 12. The data processing apparatus according to claim 11, wherein the first execution unit executes the system object via the second execution unit. 13. The system further comprises: a first structure showing an execution state of the application program; and a second structure determining an application program interface of an execution environment provided by the system object, the first execution The data processing device according to claim 11, wherein the means and the second execution means control execution of the application program based on the first structure and the second structure. 14. The first execution means is a first instruction issued by a predetermined one of the objects to execute a predetermined operation designated by a predetermined operand, and after executing the operation, the first instruction. The data processing device according to claim 11, further comprising a second instruction for returning control to the object that issued the instruction. 15. A data processing method in a data processing device comprising an application program composed of a plurality of objects and a system object composed of a plurality of objects and providing an execution environment for the application program. Data processing characterized by executing the application program by a method of interpreting and executing the converted application program and a method of dynamically compiling the intermediate code and executing the generated binary code Method.