JP2005302055A - Data processing method and device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To simplify the structure of a client to reduce a cost. <P>SOLUTION: An MVM 31a exists along with an MK 31b and constitutes a core 31 of an Apertos system. The MVM 31a constituting core 31 interprets and executes an intermediate code (I-code) and is so formed as to call a personality object (system object) by using the function of the MK 31b as required. The I-code is dynamically compiled into a binary code as required and an object being compiled is executed; and in that case, the Personality object 33 is called by the function of the MK 31b to provide a service to Applications 35. <P>COPYRIGHT: (C)2006,JPO&NCIPI

Description

  The present invention relates to a data processing method and apparatus, and more particularly to a data processing method and apparatus capable of simplifying the configuration and reducing the cost.

  Recently, personal computers have become popular. This personal computer can access a predetermined server via a network and obtain predetermined information.

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

  As described above, when the OS is different, the application program is also different. Therefore, each user needs to select and purchase an application program suitable for his / her OS. Also, 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. However, at the same time, there was a problem of high costs.

  The same thing occurs in each application program in the same OS. That is, even if one application program and another application program different from the same operate on the same OS, the two application programs must be designed separately, and as a result There has been a problem that labor and cost required to provide one application program are increased.

  The present invention has been made in view of such a situation, and makes it possible to provide one application program easily and at low cost.

  The data processing apparatus according to claim 1, a first execution unit that interprets and executes an application program converted into an intermediate code, and a binary code generation unit that dynamically compiles the intermediate code and generates a binary code And second execution means for executing the binary code and the system object.

  The data processing method according to claim 5 is a first method for interpreting and executing an application program converted into an intermediate code, and a second method for dynamically compiling the intermediate code and executing the generated binary code. The application program is executed by the above method.

  The data processing apparatus according to claim 1, wherein the first execution means interprets and executes the program converted into the intermediate code, the binary code generation means dynamically compiles the intermediate code, and the binary code. And the second execution means executes the binary code. For example, if dynamic compilation is difficult, intermediate code can be interpreted and executed sequentially.

  6. The data processing method according to claim 5, wherein a first method for interpreting and executing a program converted into an intermediate code, and a second method for dynamically compiling the intermediate code and executing the generated binary code. The application program is executed by the above method. For example, if dynamic compilation is difficult, intermediate code can be interpreted and executed sequentially.

  According to the data processing device and the data processing method of the present invention, the application program converted into the intermediate code is interpreted and executed, or the intermediate code is dynamically compiled and the generated binary code is executed. Thus, since the application program is executed, if dynamic compilation is difficult, the intermediate code can be sequentially interpreted and executed. Moreover, a portable application can be constructed by making the intermediate code simple.

  A system configuration example to which the data processing method of the present invention is applied is shown in FIG. The system includes a server 1 (data processing device), a client 2 (data processing device), and a network 3.

  That is, in this embodiment, the server 1 has two application programs. One application program 11-1 includes an execution environment 12-1 that defines an environment in which the application program 11-1 is executed, and an application program 11-1. An application program interface (API) 13-1 that constitutes an interface with the environment 12-1 is included.

  The application program 11-1 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.

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

  Similarly, the client 2 also has two application programs. One application program 21-1 includes an execution environment 22-1 that defines the environment, and between the application program 21-1 and the execution environment 22-1. It has an API 23-1, which is an interface. The application program 21-1 and the execution environment 22-1 are each composed of a plurality of objects 24-1 and 25-1.

  Similarly, the application program 21-2 also has an execution environment 22-2 and an API 23-2 that define the environment. The application program 21-2 and the execution environment 22-2 each include a plurality of objects 24-2. 25-2.

  Here, all the objects are defined as parallel objects that execute processing in parallel with other objects. Since one API set 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 as enlarged in FIG. 2, the application program 11 is composed of a collection of a plurality of objects 14. Also, by configuring the object 14 as a parallel object, the application program 11 is processed in parallel, which contributes to an improvement in execution speed. Since the object 14 is also a unit of replacement, the problem can be solved without recreating the entire application program 11 by replacing an object having a bug in operation or an object having a performance problem with an object having no error. it can. Furthermore, a new application program can be easily created by combining the object 14 as a part and combining objects as parts 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, and a home Household account book application program linked to shopping, tax calculation application program, etc.

  By sharing objects between application programs, operability can be shared. For example, an editor that inputs data in a household account book and a data input editor in home shopping can be shared.

  Next, the concurrent object will be described. The configuration of the parallel object is shown in FIG. The object 14 which is a parallel object has a table 14A of method entries disclosed to the outside, a main 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 concurrent object receives one message, and during the processing, the newly arrived message is not processed until the current execution is completed.

  In this way, if only one thread is arranged in the object, the following advantages can be obtained.

  (1) There is no need to worry about synchronization between multiple activities. That is, when there is shared data, it is not necessary to perform access to the shared data using an instruction for synchronization such as a semaphore. In other words, sending a message to an object includes that ordering.

  (2) Therefore, a program error due to a mistake in synchronization is not generated, and at the same time, the possibility of reusing the object is increased.

  (3) For example, by creating a device driver using this method, synchronization errors that occur in many cases can be prevented.

  (4) Since a synchronization error due to replacement of the device driver can be prevented, the device driver can be replaced safely.

  (5) A 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 that have previously occupied a considerable amount of time for development, leading to a reduction in the development period.

  (6) A description related to execution control between objects can be excluded from the description of the application program. For example, in the technique using multi-threads (when using a plurality of threads), it is necessary to program thread execution control in the application program, and therefore the application program is rewritten when the thread programming environment is changed. There is a need. However, when there is one thread, there is no need to describe this part in the application program, so there is no need to rewrite the application program even if the execution control method changes. The optimal execution control method for the concurrent object in its execution environment is provided by the system using the principle of dynamic extension of the object described later.

  (7) Therefore, when describing an application program, it is not necessary to consider parallel processing. Since the parallel object is a unit of parallel processing, if the parallel object is programmed, the system automatically performs the optimum execution control for the hardware and performs parallel processing. 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. Although it is dedicated to hardware, according to this method, there is no such thing.

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

  Whether or not the same execution environment 22 (22-1 and 22-2) as the execution environment 12 on the server 1 exists on the client 2 when the object is downloaded to the client 2 (2-1 and 2-2) And if it exists, download the object. If it does not exist, an execution environment identical to the execution environment on the server 1 is constructed on the client 2 and then downloaded.

  For example, in FIG. 4, when 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, the execution environment 22- of the client 2-1 is downloaded. 1, when the object 25-1A corresponding to the object 15-1A of the execution environment 12-1 of the server 1 is required, for example, the object 15-1B (inspection means) of the execution environment 12-1 -1 object 25-1B (notification means) is inquired about the feature structure (described later). In response to the answer, the object 15-1C (downloading means) of the execution environment 12-1 and the object 25-1C (downloading means) of the execution environment 22-1 are replaced with the object 15-1A of the execution environment 12-1. And 15-1B are downloaded as the objects 25-1A and 25-1B of the execution environment 22-1.

  In the conventional method, the object to be downloaded has to be created in accordance with the client API. For example, when the client is a UNIX (registered trademark) system, it is necessary to create an object by using the same UNIX (registered trademark) system on the server or constructing some kind of cross development environment. If the server and the 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 a case where a dedicated execution environment is provided. In order to guarantee a sufficient execution speed, it is necessary to provide a high-speed CPU (Central Processing Unit). This leads to an increase in the cost of the device.

  In contrast, the present system solves this problem by downloading the execution environment at the same time as downloading the application. That is, by constructing only the execution environment 22 currently required by the client 2 in the client 2, it is not necessary to prepare unnecessary resources in the client 2. For example, if the client 2 does not require 3D graphics, the library is not necessary.

  In addition, when the client 2 is watching a movie with VOD (Video On Demand), a service for interaction with the user (a service that is unnecessary when watching a movie) is temporarily deleted from the client. Minutes of computational resources can be allocated to other jobs. For example, the resource can be used as a buffer for prefetching video data from the server 1. The service for interaction is downloaded from the server 1 when it becomes necessary.

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

  (1) All application programs

  (2) Device driver group (for example, MPEG driver, ATM driver, image control driver, etc.) for controlling hardware resources provided in the client

  (3) Object groups 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 that sends video data and application programs, or a device that sends 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 always need to be connected to the network 3. Since an execution environment can be provided for each application program, an optimal execution environment can be prepared for each application program.

  In the conventional method, it is necessary to estimate the characteristics of the application in advance at the time of system construction. For example, when an application program needs to handle video data, it needs to have a system interface for that purpose, for example, a real-time scheduling or a user interface such as a VCR for handling video data. If the application uses 3D graphics, it is necessary to have a library for that purpose. Therefore, the system tended to be enlarged. UNIX (registered trademark) and Windows (registered trademark) are typical examples, and the amount of memory required by the system increases with each version. In this system, it is sufficient to provide only the minimum necessary functions for executing the application, and this problem of the conventional system is solved.

  By configuring the application program 11 as a collection of a plurality of objects and mounting the object as a parallel object, it becomes possible to execute the object in parallel, and the object can be downloaded simultaneously with the execution of the application program. it can. At this time, as shown in FIG. 5, the time required to load a single application program can be hidden from the user by incrementally downloading the objects necessary for executing the application program.

  For example, as shown in FIG. 5, the objects 14-1-1 to 14-1-11 of the application program 11 of the server 1 are changed to the objects 24-1-1 to 24-1-111 of the application program 21 of the client 2. When it is necessary to download the object, instead of downloading each object at random, the object 14-1-1 to 14-1-3 required first in executing the application program 21 is changed to the object 24-1−. Download first as 1 to 24-1-3.

  For the time being, since the application program 21 can be activated if these three objects exist, the application program 21 starts its processing. While the processing is being executed, the remaining objects 14-1-4 to 14-1-11 are designated as the objects 24-1-4 to 24-1-111 of the application program 21, and the second to fourth objects. Download in order. Also in the second to fourth downloads, download is performed in order from the object that is necessary first in the process.

  Since the application program 21 has already started the processing of the application program 21 at the time when the application program 21 has downloaded the objects 24-1 to 24-1-3 and started the processing, it is as if all the objects You can recognize that the download is complete. That is, the user is only aware of the time required to download three objects, which is shorter than the time required to download eleven objects. In other words, the time for downloading the eight objects can be substantially hidden (not conscious) from the user.

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

  Here, the incremental download means that an application unit or an execution environment is not downloaded at a time, and an object unit or a part thereof is downloaded as needed. In the case of downloading an application program in conventional personal computer communication, the compressed application program is downloaded all at once, so that the application program cannot be used unless all the downloads are completed. Also, for example, in the system boot up to now, the entire system is read into the memory and then started up. In the case of a UNIX (registered trademark) diskless workstation, the system is started after all the OSs are read from the server into the memory. Therefore, the system cannot be used until all the reading is completed. However, if you do an incremental download, that will not happen.

  This method has the following effects when applied to an STB (Set Top Box) as the server 1 and the client 2. First, it can be used as soon as the STB is turned on. Unlike the current personal computer, there is no need to irritate and wait for the system to start up. Since STB has a strong personality as an electric appliance for home use, it is not preferable to make the user wait until the system is started up.

  When the STB is powered on, the STB first tries to download the necessary objects and begin execution. The user's waiting time is only the first download time of this object. Since the download time of a typical object is several milliseconds to several tens of milliseconds, by providing an appropriate user interface, this time is sufficiently negligible for the user. Thereafter, necessary objects are downloaded in parallel with the system startup process as the system startup process progresses.

  In addition, from the viewpoint of cost, the STB does not have abundant calculation resources such as a server, so there are restrictions even when a plurality of applications are executed simultaneously. For example, when considering a VOD service selected by a navigation application and watching a movie, when watching a movie starts, the resources (memory) occupied by the navigation application are released to watch the movie. Can be used for applications. Then, when the navigation application becomes necessary again, the resource (an object for managing the memory) is downloaded.

  Here, the “when it becomes necessary” is a time when a 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 a delay caused by downloading during message communication. Thereby, the effectiveness of incremental downloading can be increased.

  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, so that the download order specialized for the application programs 11 and 21 is determined. A meta object to be controlled can be prepared as one of the objects 15 and 25 (for example, the object 25-1C in FIG. 4 is a meta object). Thereby, it is possible to specify the download order of the objects used by the objects, which is suitable for a specific application, and to minimize the waiting time of the user due to incremental downloading.

  The function of downloading an object from the server 1 to the client 2, the function for checking the compatibility of the execution environment of the object, and the function for constructing the execution environment are important in realizing this system. It is assumed that all the devices (client 2) constituting the function should have at least. In this specification, this function is called a meta standard. With this meta-standard, the API of an execution environment such as an OS can be freely expanded, and it becomes possible to cope with all types of applications in the future by minimal standardization and its extension.

  For example, in the system shown in FIG. 6, each server 1-1, 1-2 and each client 2-1, 2-2 run an OS having a unique API. That is, in the client 2-1, an 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, an API 23-2 (API # 3) for the application program 21-2 is formed by the execution environment 22-2.

  For this reason, APIs corresponding to these APIs are prepared in advance in servers that download programs to these clients 2-1 and 2-2. In this embodiment, in the server 1-1, an API 13-1 for the application program 11-1 is formed by the execution environment 12-1, and this API 13-1 is an API 23-1 ( API (API # 1) corresponding to API # 1).

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

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

  There has been a trend in this field so far to standardize the OS in each client into one OS. However, by defining such a meta standard and providing an API corresponding to the API of each client only on the server side, it is not necessary to determine the standard.

  By not defining one OS standard, it is possible to configure an object that implements a system service, including an application, 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 the conventional system. For example, software written for UNIX (registered trademark) does not operate unless rewritten on Windows (registered trademark). In order to realize this function with application-level software, it is necessary to introduce software that absorbs OS dependency. However, the independence of the OS that implements system services such as device drivers can be achieved using this method.

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

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

This makes it possible to:
(1) The 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. Since home appliances are used by general consumers who are not computer specialists, it is not appropriate to update software with an installer such as found on some computers.

  (2) The product cycle can be lengthened. For example, although the model change of a television receiver is repeated every year, a general consumer does not replace a television receiver every year. However, with this system, all software problems can be provided to the user with the latest functions, so model changes due to software function expansion can be eliminated. This is also true for STB.

  (3) It can cope with changes in user interface preferences. For example, a user-friendly menu format is provided for users who have started using the device for the first time, but as the user becomes familiar with how to use the device, the user interface should be changed to a direct operation that allows direct operation. Can do. In this case as well, both procedures are not provided on the client side, but a user interface according to the skill level of the user at that time can be provided 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 of FIG. 8, an execution environment 22-2 is generated so that a new service can be received for the object 24-1B of the application program 21-1 in the client 2. The necessary objects 25-1A and 25-1B are migrated (transferred) from the execution environment 22-1 to the execution environment 22-2 so as to become the objects 25-2A and 25-2B. Further necessary other objects 25-1C and 25-1D are also migrated to the execution environment 22-2.

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

  In this way, for example, when it is necessary to extend real-time scheduling, a new execution environment for that purpose is generated in the client, and necessary objects are moved to the new environment. No changes need to be made to the object, and the object can be serviced in real time.

  As a result, the following effects can be obtained.

  (1) Since it becomes possible to cope with new functions without changing the object of the application program, the life of the application program is lengthened and the possibility of reuse is increased. In the conventional method, since the application program includes dependency code for the execution environment, changing the execution environment means rewriting the application program.

  (2) In the case of an application program for an embedded device, the high-function control software portion of the device including the user interface is the portion that you want to reuse as long as the model does not change significantly. It is a part that wants to shorten the development period simply by extending the function. However, if this part contains code dependent on the execution environment, the work for reuse becomes complicated. Until now, there was no strategy for this part, but with this method, this work can be automated or minimized.

  Specifically, this system can be 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 service provided for each STB vendor. For example, a service provider that provides a movie of a movie company A can change the quality of images between the STB of company B and the STB of company C that receive the movie.

  (3) The system processing method is changed according to the compression method of 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, since most functions of the system can be downloaded from the server 1, it is not necessary to provide the client 2 with various functions in advance, and it is sufficient to provide the minimum functions. FIG. 9 shows the minimum functions of the client 2 in this system. In other words, 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 are formed in the client 2 at a minimum.

  The device drivers that need to exist in advance are the input driver that processes input, the timer driver that manages time, and the screen driver objects 24-1A, 24-1B, and 24-1C that control display, and the system objects are , An input handler that manages input, a boot protocol that manages activation, and a memory manager that manages memory 24-2A, 24-2B, and 24-2C. Higher-function 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 out by a server is dynamically configured. In FIG. 10, in order to download the shopping application program 11-2 from the server 1, a 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 configured in the client 2-2, and the movie is changed from the server 1 to the movie. The application program 11-1 is downloaded.

  For example, the following processing can be considered.

(1) When the user selects a movie At this time, the navigation application 11-3 is downloaded to the execution environment 22-1 of the client 2-1, for example, 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, an object 15-1 such as video stream management, data prefetch buffer management, VCR function, etc. 2 is downloaded as an object 25-3 to the second execution environment 22-3.

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

  That is, the server 1 negotiates with the client 2 on the possibility of object migration between the meta-object space on the server 1 side and the meta-object space on the client 2 side in the first phase (negotiation phase). Do. In the second phase (movement phase), the object is actually transferred.

  Object migration is a meta-level process that transfers the computational information in use by an object's internal information and, if necessary, the associated object. The internal information of the object is expressed by a meta level object called a descriptor. The descriptor actually holds the name of the meta-object that manages the object. Common descriptors are 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-name that manages the naming of objects. Holds the name of the object, etc.

  In the first phase (negotiation phase), the possibility of movement of the object is checked. That is, object migration may not be desirable depending on the meta-object space. For example, if the meta-object space that manages the device driver moves an object (device driver), it does not make sense to move the hardware device if it does not actually exist on the client 2 side. It will disappear. Also, a meta-object that manages a memory segment of an object using a 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 * Descriptor :: CanSpeak (Feature * pFeature)

  This method executes a CanSpeak operation on the descriptor in the meta-object space on the client 2 side.

  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 can be accepted by itself (client 2). On the server 1 side, the compatibility of the meta-object space can be known by inspecting the feature structure returned from the client 2 side.

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

  Full compatibility means when the object can continue to run completely after moving. Semi-compatibility means that certain restrictions are imposed on the execution of objects after movement. And incompatibility means that the object cannot continue execution after moving.

  In case of incompatibility, object migration is not performed. In the case of semi-compatibility, the user determines whether to perform migration or not. Actually, an exception is returned to the user, so that the migration is determined by the exception handling routine. In the case of full compatibility or semi-compatibility, when object migration is performed, migration is performed according to the contents of the feature structure returned earlier.

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

  Descriptor :: Descriptor ()

  The previous CanSpeak method is sent to this descriptor. At this time, necessary meta-objects are generated, references are generated, and necessary information is registered based on the feature structure information.

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

  The actual operations related to the movement and transfer of meta-objects are performed in this second phase (movement phase), utilizing the feature structure obtained by the negotiation phase.

  The actual meta-object move and transfer in the move phase is triggered by the following methods:

  Descriptor & Descriptor :: 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 referenced 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 used by migrators (meta-objects that are included in the meta-object space and are responsible for object migration).・ CanonicalContext & Context :: asCanical ()
Convert a machine-dependent Context structure to a machine-independent form. This protocol is executed when the feature structure indicates that direct conversion of the Context is not possible.
・ Context & Context :: operator
= (Context & source)
・ Context & Context :: operator
= (Canonical Context & source)
The current Context (referenced by this) is initialized with the Context referenced by the source.
・ Canonical Segment & Segment :: asCanonical ()
Convert the machine-dependent Segment structure to a machine-independent format. This protocol is executed when the feature structure indicates that direct conversion of the Context is not possible.
・ Segment & Segment :: operator
= (Segment & source)
・ Segment & Segment :: operator
= (Canonical Segment & source)
The current this (referenced) Segment is initialized with the Segment referenced by the source, and a necessary memory area is copied.

  FIG. 11 shows the structure of the feature structure. As shown in the figure, the object description and environment description pointers are described in the entry.

  In the structure indicated by the object description pointer, the object name is described, and further, a pointer of the same structure as the structure indicated by the environment description pointer is described. In addition, a resource request of this object is described.

  Further, the environment name is described in the structure indicated by the pointer of the environment description, and further, the hardware resource information (resource information of client hardware) of the client and the resource request (resource requirement of this execution environment) environment) and a list of meta-objects constituting the execution environment (list of metadata constructing environment) are described.

  A specific example of the contents of the feature structure is as follows.

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

(2) Information about meta-objects Hardware meta-object * Processor type * Data expression format Segment meta-object * Size * Expandability, management policy * Layout context meta-object * Register information * Temporary variable amount * Processor state 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 state * Scheduling policy Dependency management meta-object * Number of external names

  As described above, when each client has a different OS, the OS of each client is determined from this feature structure, and the server downloads an object corresponding to the OS.

  FIG. 12 shows a configuration example of an Apache (trademark) system to which the data processing system of the present invention is applied. In this Apache system, the Apache Micro Virtual Machine (MVM) 31a (first execution means) is together with the Apples Micro Kernel (MK) 31b (second execution means) and constitutes the core 31 of the Apache system. . The MVM 31a constituting the core 31 interprets and executes an intermediate code (I-code) described later, but calls a personality object (system object) using the function of the MK 31b as necessary.

  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 dynamically compiles I-code into native code (binary code, machine code) as needed. In addition, an object that has been compiled into a native code is executed in advance. In this case, the Personality object 33 (binary code generation means) is called by the function of the MK 31b, and a service is provided to the application (Applications) 35.

  The MVM 31a and MK 31b constituting the core 31 shown in FIG. 12 are surrounded by a device driver object (Device drivers) 32 and a Personality object (Personality component objects) 33, and further outside for application programming. A class system (Class Libraries) 34 is prepared, and an application 35 is prepared outside of the class system 34.

  The layer of the Personality object 33 enables the Apache system to provide various OSs (Operating Systems) and Virtual Machines (virtual machines). For example, a Java (registered trademark) program is executed by executing a Java (registered trademark) byte code that is an intermediate code obtained by compiling a Java (registered trademark) program by a Personality object for the Java (registered trademark) program. Is done.

  In order to realize a high degree of portability, the Apache system compiles a program into I-code (intermediate code) and manages object methods. However, I-code is not designed on the assumption of interpretation execution (executed while interpreting a program), but is designed to be compiled into native code by a dynamic compiler. However, when dynamic compilation is difficult due to various restrictions, the MVM 31a interprets and executes the I-code.

  However, in most cases, the I-code is compiled into a native code and directly executed by the CPU constituting the system. Therefore, there is almost no loss of real-time performance or sacrifice of processing speed with execution by Virtual Machine.

  The I-code is composed of two instruction sets (OP_M, OP_R) having a sufficiently high level of abstraction as will be described later with reference to FIG. 22 in order to realize a high level of inter-operability. (Semantic structure) is strongly associated with the interface of MK31b. That is, the instruction set is strongly influenced by the structure of the Apache system shown in FIG. Thereby, in the Apache system, it is possible to realize high portability and inter-operability while assuming a native code.

  Next, specifications of 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 a logical structure of the MVM 31a and MK 31b shown in FIG. The logical structure of both is basically the same, and consists of active context 41, message frame 42, and execution engine 43. MVM 31a supports execution by I-code, and MK 31b supports execution by native code. Yes.

  In FIG. 13, an active context 41 indicates a context that is currently being executed (described later with reference to FIG. 14), and a message frame 42 indicates a message body for the MVM 31 a and the MK 31 b that constitute the nucleus 31.

  In the case of the MK 31b, the location where the message body exists depends on the mounting method, and may be assigned to a memory as a stack frame or may be assigned to a heap. Also, some CPU registers may be allocated. On the other hand, in the case of MVM 31a, the message frame indicates an operand following the instruction code. Depending on the implementation, internal registers may be required in addition to these, but these registers are independent of this specification.

  In FIG. 13, the execution engine 43 executes I-code and native code. Further, the execution engine 43 of the MVM 31a includes a primitive object 44, which is a code for processing a primitive object described later with reference to FIG.

  FIG. 14 shows the logical structure of Context and Descriptor. A Context structure 51 indicating one execution state of a program has fields such as object, class, method, and meta. Of these, the method further includes fields of icode and minfo. The Context structure 51 holds the state of the MVM 31a, corresponds to a register of the CPU, and is completely independent of memory management, a communication method between programs, and the like.

  The Context structure 51 is a Context primitive object, and each field thereof is linked to predetermined information as described later with reference to FIG. The Context structure 51 is deeply dependent on the mounting of the core 31 (MVM 31a and MK 31b), but FIG.

  An important field in the Context structure 51 is a meta field, which points to the Descriptor structure 52. The entry of the Descriptor structure 52 includes three sets of #tag, context, and selector. The Descriptor structure 52 determines an API (Application Programming Interface) of the Personality object 33. #Tag represents the name of the API, and context and selector represent the API address.

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

  The class 62 mainly holds methods. The class 62 includes a name (class name), a part depending on the implementation (class dependent field), and a link table (method table) to the I-method structure 63. The I-method structure 63 is a Block primitive object and includes a header (Header), an I-code part, and a variable table (Variable table). magic # is the 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, a gray part (Context 51, I-method 63) is a part depending on the MVM 31a, and is a structure required when the MVM 31a interprets and executes the I-code.

  FIG. 16 illustrates the structure 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 points to the class dependent field of the class 62. Further, the method field indicates the I-method 63, and the icode of the method field indicates the I-code of the I-method 63. “icode” corresponds to a program counter and indicates a program being executed. The “vtable” of the method field indicates the variable table of the I-method 63.

  The temporary field indicates a temporary data storage area, and the meta field indicates the descriptor 52 as described above. Further, the class pointer of the object 61 points to the class 62, and the method table of the class 62 points to the I-method 63.

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

  The MVM 31a is configured to process the type shown in FIG. 17, and when the type is T_PRIMIVE, the value column refers to the primitive object. In this case, a set of <P_CLASS, P_BODY> as shown in FIG. 18 such as <P_INTAGER, immediate>, <P_STRING, address to heat> is stored in the value column. FIG. 18 shows a list of primitive objects and their interface names. FIG. 19 to FIG. 21 show examples in which the interface of the primitive object shown in FIG. 18 is described by the Interface Definition Language (IDL) method. The IDL method is disclosed in “CORBA V2.0, July 1995, P3-1 to 3-36”.

  In FIG. 17, when the type is T_POINTER, an ID for referring to the object is stored in the value column. This ID is the only value in the system whose position is independent, and the position of the object corresponding to the ID is specified by the Personality object 33.

  FIG. 22 shows two instruction sets that are interpreted and executed by the MVM 31a. In FIG. 12, the instruction set OP_M is an instruction that enters from the outside to the inside, and the instruction set OP_R is an instruction that returns 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 by a primitive object. In order to execute the application 35 more efficiently, the compiler generates I-code so that some processing is performed by the primitive object. Thereby, for example, the arithmetic operation of Integer is processed by the first primitive object in FIG.

  Next, the interface of MK31b is defined. FIG. 23 shows an interface of the microkernel (MK) 31b. The logical structures of the MVM 31a and MK 31b are the same as shown in FIG. 13, and the MK 31b processes the instruction sets OP_M and OP_R shown in FIG. 22 as system calls.

  The Applet system configured as described above can be applied to the client 2 (2-1, 2-2) shown in FIG. 4, for example. Then, an arbitrary execution environment for executing a predetermined application can be constructed on the client 2 by downloading an arbitrary one other than the core 31 shown in FIG. 12 from the server 1.

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

  (1) All application programs

  (2) Device driver group (for example, MPEG driver, ATM driver, image control driver, etc.) for controlling hardware resources provided in the client

  (3) Object group (personality object) that provides 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 optimal execution environment for the application program can be constructed on the client.

  For example, when a Java (registered trademark) program is to be executed, a personality object 33 for Java (registered trademark) and a Java (registered trademark) program (application) 35 are downloaded from the server 1. With this personality object 33, the Apache system can provide Java (registered trademark) Virtual Machine. The downloaded Java (registered trademark) program is once compiled into intermediate code called Java (registered trademark) bytecode by a compiler, and executed by the Java (registered trademark) Virtual Machine. Alternatively, as described above, it may be executed after being compiled into a native code.

  In the above embodiments, a predetermined object is downloaded from a server to a client. However, when an object is downloaded from a predetermined client to a predetermined server, or when an object is downloaded between servers or between clients. In addition, the present invention can be applied.

  In the above embodiment, the I-code is configured by two instructions, but the present invention is not limited to this.

It is a figure which shows the structural example of the system to which the data processing method of this invention is applied. It is a figure which shows the structure of an application program. It is a figure which shows the structure of a parallel object. It is a figure explaining the download of the object with respect to the client of multiple vendors from a server. It is a figure explaining incremental download. It is a figure explaining a meta standard. It is a figure explaining the dynamic change of an object. It is a figure explaining the dynamic expansion of an object. It is a figure explaining the minimum function of a client. It is a figure explaining construction of a client environment suitable for an application and its dynamic reconfiguration. It is a figure explaining the structure of a feature structure. It is a figure which shows the structural example of the Apache system which applied the data processor of this invention. It is a figure which shows the logical structure of MVM and MK. It is a figure which shows the logical structure of Context and Descriptor. It is a figure which shows the whole structure of MVM. It is a figure which shows Context and the data structure of the circumference | surroundings. It is a figure which shows the type of Variable table entry. It is a figure which shows the list | wrist of a primitive object, and its interface name. It is a figure which shows the interface of a primitive object. It is a figure which shows the interface of a primitive object. It is a figure which shows the interface of a primitive object. It is a figure which shows an I-code instruction set. It is a figure which shows the interface of MK.

Explanation of symbols

  1 server, 2 client, 3 network, 11 application program, 12 execution environment, 13 application program interface, 14, 15 object, 21 application program, 22 execution environment, 23 application program interface, 31 core, 31a MVM, 31b MK, 32 Device drivers, 33 Personal component objects, 34 Class libraries, 35 Applications, 41 active contexts, 42 message frames, 43 execution engines, 44 prime engines, 44 prime engines object, 62 class, 63 I-method

Claims (5)

In a data processing apparatus composed of 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,
First execution means for interpreting and executing the application program converted into intermediate code;
Binary code generation means for dynamically compiling the intermediate code and generating binary code;
A data processing apparatus comprising: the binary code and second execution means for executing the system object. The data processing apparatus according to claim 1, wherein the first execution unit executes the system object via the second execution unit. A first structure indicating an execution state of the application program;
A second structure for determining an application program interface of an execution environment provided by the system object,
2. The first execution unit and the second execution unit control execution of the application program based on the first structure and the second structure, respectively. Data processing equipment. The first execution means is issued by a predetermined one of the objects and executes a predetermined operation specified by a predetermined operand, and after executing the operation, the instruction is issued. The data processing apparatus according to claim 1, further comprising: a second instruction that returns control to the object. In a data processing method in a data processing apparatus composed of 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,
The application program is executed by a method of interpreting and executing the application program converted into the intermediate code, and a method of dynamically compiling the intermediate code and executing the generated binary code. Data processing method.

Images