DE112012000693T5 - Execute a variety of instances of an application - Google Patents

Abstract

The present invention discloses a method and system for executing a plurality of instances of an application, the method comprising: starting execution of a root instance of the application, the root instance including at least one thread; in response to a thread of the root instance, when executed, arriving at a predetermined freeze point in the application, stopping execution of all threads of the root instance; in response to starting execution of an instance of the application, replicating the execution state of all threads of the root instance as the execution state of all threads of the instance; and continue to run all the threads of the instance of the application. The method and system can save program execution data storage space and data storage space in a multi-tenant cloud computing environment.

Description

FIELD OF THE INVENTION

The present invention relates generally to computer application execution, and more particularly to a method and system for executing a plurality of instances of an application.

DESCRIPTION OF THE PRIOR ART

Cloud computing is an emerging network service mode. An IDS analysis report notes that in 2009, $ 359 billion of global IT spend came to $ 17 billion from investments in cloud computing. Other studies also indicate that two-thirds of companies plan to expand their use of public clouds.

A multi-tenancy architecture is the most common architecture in cloud computing, and multi-tenancy borrowed and developed many concepts from host computing, introducing the concepts into the system of x86 servers and extending the original concepts Enormous, supporting thousands of "clients" inside and outside companies. Such "tenants" can be any application (either within or outside of companies) in any company that has its own security requirements and a dedicated virtual computing environment, and the environment can handle multiple or all levels of IT. Include enterprise architecture from data storage to the user interface. In fact, all interactive applications are naturally targeted to multiple users or "multi-tenancy".

Multi-client capability means, in short, that a single software instance can serve a variety of organizations (or users). Software that supports multi-tenant capability must, through its design, allow each organization using the software to use a separate virtual instance and be able to customize the virtual instance. The advantage of multi-tenancy is the reduction in overall resource utilization and the cost of running an application by sharing a software instance with a variety of organizations; Moreover, because all organizations share the same set of core code, updating and developing the software is easier; Furthermore, by using the multi-tenant architecture, physical resources and software resources can be reduced, management simplified, and efficiency improved.

To meet the security and isolation needs of multiple tenants (users), in some cloud computing environments, the cloud computing administrator must create a separate instance of the application for each user. Although a plurality of instances of the application execute on the same basic code, it is currently difficult to use the same basic code, causing unnecessary resource consumption, e.g. B. the memory space occupied due to multiple loading of the same code; moreover, the same global data structure is used in different instances of the application, causing repeated data space usage, and so on.

In the current "multi-tenant" architecture, e.g. For example, for a Java ^™ application, this problem is solved by replicating the JVM. This procedure replicates the existing JVM to reboot a new replicated JVM and share the memory pages and execute another identical Java application on the replicated JVM. In this method, however, process-level sharing occurs with coarse granularity of sharing and limited memory space savings. (Java and all Java-based trademarks and logos are trademarks or registered trademarks of Oracle and / or its affiliates).

In US 7,426,720 discloses a system and method for dynamically preloading classes by cloning workspace of a main runtime system process. A main runtime system process is executed. A representation of at least one class is provided by a source definition provided as object-oriented program code. The representation is interpreted and instantiated as a class definition in a working memory space of the main runtime system process. The work space is cloned in response to a process request as a subordinate runtime system process, and the child runtime system process executes and inherits the memory state of the parent process that represents the data structures and state that correspond to the preloaded classes. (See abstract and columns 4 and 5, lines 47 to 6.)

In US 4,742,450 describes a method for allowing data to be exchanged in a UNIX * file between two UNIX processors running concurrently on two virtual machines discloses a virtual page-segment virtual memory data processing system. A Shared Copy-On-Write (SCOW) command is created for the UN IX-type operating system that, when executed in response to a system call, causes a single process to map the specified UNIX file to a unique virtual memory segment , An allocation node data structure is set up to store the ID of the unique segment and to maintain a count of the number of users sharing the unique segment. A system call to the SCOW command by the second process involving the same UNIX file examines the mapping node data structure to determine if the file is currently mapped to the SCOW mode. Subsequent instructions in the application programs running in parallel on the virtual machines work on the copy of the file in the unique segment so that all data that is changed, ie written by a process, is available to be read by the second process become. FNT UNIX is a trademark of AT & T. (See abstract and columns 4 and 5, lines 33 to 2.)

In US Pat. No. 7,536,525 discloses a system and method for hot cloning in a distributed network. In one embodiment, a method for cloning a virtual machine from a source system to a target system includes freezing writes to a data storage file with memory blocks such that subsequent writes create new memory blocks for the original virtual machine. The method further includes freezing writes to a memory content so that subsequent writes are stored in buffers. The method further includes copying the memory contents to the target system, wherein the copied memory contents generate a clone. The method further includes thawing the memory contents by merging the writes stored in the buffers and thawing the writes to the data store file such that subsequent writes occur normally. The method further includes configuring the clone based on the target system. The method further includes generating a new memory block for all writes to the data store file, wherein the new memory block is not shared. (See abstract, lines 20 to 40 and columns 6 and 7, lines 52 to 3.)

In US Pat. No. 7,657,888 For example, there is disclosed a method of increasing the efficiency of processing virtual machines. A parent virtual machine is deployed on a host computer. The parent virtual machine is suspended temporarily or permanently. A child virtual machine is created in a new location by splitting the parent virtual machine. The child virtual machine may initially not contain all the stored data associated with the parent virtual machine. (See abstract, column 4, lines 44 to 56 and column 5, lines 4 to 40.)

In WO 2007/036072 A method and apparatus for accelerated virtual machine (VM) booting in a VM cluster environment is disclosed. In one embodiment, at least one virtual machine is started within a host platform. After initialization, a VM can issue a hyper-call to a VM Monitor (VMM) of a VM Host platform. In response, the VMM may capture a runtime image of the VM. In one embodiment, the VMM loads the runtime image of the VM within a node of the host platform as a subordinate VM. In an alternative embodiment, the VMM issues a VM clone command to a VMM of a next host platform, including the runtime image of the VM. In response, the VMM of the next host platform loads the runtime image of the first VM within a node of the second host platform as a cloned VM. (See pages 11 and 12, sections [38 to 41].)

In US 2010/0223613 discloses a system and method for isolating processes executed within a computing device. A process is loaded onto a virtual machine that operates under the control of a hypervisor connected to an operating system kernel for data exchange. A subset of an application programming interface (API) is offered to the virtual machine, which enables the process to connect to the operating system kernel through the API subset. The process is then executed on the virtual machine. (See summary and page 4, sections 37 and 38.)

In US 7,421,698 discloses a system and method for dynamically and persistently tracking incremental profiling data in an environment of a process cloning application. A main runtime system process is executed. A working memory space of the main runtime system process is cloned as a subordinate runtime system process in response to a process request. The child runtime system process is executed. To run the child runtime system process, incrementally collect profiling data created a profile. The profiles of the child runtime system process are returned to the main runtime system process for the benefit of subsequent child runtime system processes. In another embodiment, the profiles of the subordinate runtime system processes are stored in a persistent data store for use by the main runtime system process on the next boot up. (See abstract and columns 2 and 3, lines 51 to 18.)

In "Cloneable JVM: A New Approach to Starting Java Application Faster" by Kawachiya, Ogata, Silva, Hideaki, Nakatani and Nakatani, an approach is disclosed in which the startup effort in Java is unnecessary. (See summary and also section 3.1.)

BRIEF SUMMARY OF THE INVENTION

Therefore, a new method, system, and computer program are provided for executing a plurality of instances of an application according to an embodiment of the present invention to save the data storage space occupied by the application.

According to one aspect of the present invention, there is provided a method of executing a plurality of instances of an application, the method comprising:
Starting execution of a root instance of the application, wherein the root instance includes at least one thread; in response to a thread of the root instance, when executed, arriving at a predetermined freeze point in the application, stopping execution of all threads of the root instance; in response to starting execution of an instance of the application, replicating the execution state of all threads of the root instance as the execution state of all threads of the instance; and continue to run all the threads of the instance of the application.

In one embodiment, the execution state includes at least: the current stack, the values of registers, and the current instruction of a thread.

In one embodiment, the current execution state stack contains a reference to an instance object in the instance, the reference to the instance object being initialized to point to the root instance object.

In one embodiment, continuing to execute all threads of the instance of the application comprises: receiving a write to a field of an instance object; in response to a reference to the instance object referring to a root instance object: associating a data storage area with the instance object; Pointing the reference to the instance object to the data storage area; Perform the write operation in the data storage area.

In one embodiment, the method further comprises: in response to the reference to an instance object not referencing a root instance object, performing the write operation in the data storage area referenced by the reference to the instance object.

In one embodiment, continuing to execute all threads of the instance of the application comprises: receiving a write to a field of an instance object; in response to a corresponding field of a root instance object referenced by the reference to the instance object being flagged as not yet performing a write operation: allocating a data storage area for the field of the instance object; Flag the corresponding field of the root instance object so that it has performed a write operation; Perform the write operation in the data storage area.

In one embodiment, the method further comprises: in response to a corresponding field of a root instance object referenced by the reference to the instance object being characterized as having performed a write operation, performing the write operation in the data storage area corresponding to the field associated with the instance object associated with this write operation.

In one embodiment, the method further comprises: flagging an attribute of a root instance object as "read only" in response to a thread of the root instance executing at a predetermined freeze point in the application upon execution.

According to another aspect of the present invention, there is provided a system for executing a plurality of instances of an application, the system comprising: root instance launching means arranged to start executing a root instance of the application, the root instance including at least one thread; a root instance suspending means, arranged in response to a thread of the root instance, when executed, arriving at a predetermined freezing point in the application to halt the execution of all threads of the root instance; a replicating means arranged to execute state of all the threads of the root instance as the execution state of all in response to starting execution of an instance of the application To replicate threads of the instance; and execution execution means arranged to continue to execute all the threads of the instance of the application.

In one embodiment, the execution state includes at least: the current stack, the values of registers, and the current instruction of a thread.

In one embodiment, the current execution state stack contains a reference to an instance object in the instance, the reference to the instance object being initialized to refer to a root instance object.

In one embodiment, the execution continuation means comprises: a write operation receiving means arranged to receive a write operation to a field of the instance object; data storage allocation means arranged to, in response to a reference to the instance object referencing the root instance object, allocate a data storage area for the instance object; a reference modifier configured to, in response to a reference to the instance object received by the write operation receiving means refering to the root instance object, refer the reference to the instance object to the data storage area associated with the data storage area allocation means; write operation executing means arranged in response to the reference to the instance object received by the write operation receiving means referring to the root instance object to execute the write operation in the data storage area allocated by the data storage area allocation means.

In one embodiment, the write operation executing means is further arranged to execute the write operation in the data storage area allocated by the data storage area allocation means in response to the reference to the instance object received by the write operation receiving unit not pointing to the root instance object.

In one embodiment, the execution continuation means comprises: a write operation receiving means arranged to receive a write operation to a field of the instance object; a flag set up in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object being characterized as not yet executing a write operation, the corresponding field of the root instance object so flag that it has performed a write operation; a data storage area allocation means arranged to designate, in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object, that it has not yet performed a write operation, a data storage area for Assign the field of the instance object; a write operation executing means arranged in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object being characterized as not yet executing a write operation, the write operation in the execute data storage area associated with the data storage area allocation means.

In one embodiment, the write operation executing means is further arranged in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object being executed to perform a write operation, the write operation in execute the data storage area allocated by the data storage area allocation means.

In one embodiment, the system further comprises: a root instance object identifier configured to read an attribute of the root instance object in the root instance as "read only" in response to a thread of the root instance executing at a predetermined freeze point in the application upon execution "To mark.

The invention can also be implemented in computer software.

BRIEF DESCRIPTIONS OF THE DRAWINGS

Embodiments of the present invention will now be described by way of example only and with reference to the following drawings:

1 illustrates the process of a method for executing a plurality of instances of an application according to an embodiment of the present invention;

2 further exemplifies the method of executing a plurality of instances of an application by using the language Java as an example;

3 illustrates, according to an embodiment of the present invention, a process that an instance performs a write operation;

4 illustrates, according to an embodiment of the present invention, another process that an instance performs a write operation; and

5 schematically illustrates, according to an embodiment of the present invention, a structural block diagram of a system for executing a plurality of instances of an application.

(It should be noted that the same reference numerals usually denote the same components in the exemplary embodiments of the present invention.)

DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS

Preferred implementations of the present invention will be described in more detail with reference to the accompanying drawings, in which the preferred embodiments are shown. However, the present invention can be embodied in various forms and should not be construed as limited to the embodiments set forth herein. On the contrary, these embodiments are provided to give greater accuracy and completeness to the present invention and to fully convey the scope of the present invention to those skilled in the art.

Programmers typically invoke programs that run in the computer processes, and each process has its own memory space. For example, for an IE browser program, an IE browser window is opened each time an IE browser process is started. And a thread refers to an execution flow in a process and is sometimes called an execution context. A single process may be composed of a plurality of threads, that is, a plurality of different threads may be executed concurrently in a single process and each perform different tasks. When a plurality of threads are simultaneously executed in a process, such an execution mode is called "parallel execution". The main difference between a thread and a process is that each process needs the operating system to create a separate memory address space for it, whereas all the threads in a single process work in the same one address space, and these threads can share the same memory and system resources, z. For example, share an object or an open file. Existing operating systems, such as Mac, ^Windows® , typically use the concept of multiple threads and consider a thread as a basic execution unit. (Windows is a trademark of Microsoft Corporation in the United States, other countries, or both.)

To translate multi-tenant architecture to an application such as the Java language in the existing cloud computing environment, one virtual machine replicates and another similar application runs on the virtual machine. The virtual machine is a process, and the replicated virtual machine process can share memory pages with the original virtual machine process; however, memory pages are large data storage devices in memory, so the granularity of such sharing is limited and the data storage space saved is limited.

In addition, in many scenarios, it is often necessary to run a variety of instances of an application. An instance once signifies execution of an application, e.g. For example, executing a plurality of Eclipse instances refers to running the Eclipse application multiple times; or executing a plurality of instances of a Java application refers to running the Java application multiple times in the Java virtual machine process. An instance is originally a virtual concept and does not have its own programmentality; a single instance may contain a plurality of threads; and when a plurality of instances are running in the same process, the instances can share the memory space. Each instance can contain a multitude of threads, and the current multi-tenant solutions only have replication at the virtual machine process level; h., processes share memory pages together. However, a plurality of threads included in a plurality of instances have no sharing between them, whereas the plurality of threads within the instances have many similarities. Because the datastores are independent of instance processes and share process usage, memory pages usually can not be shared because of smaller differences, and the coarse granularity of the shared benefit wastes a lot of application execution space.

Therefore, an embodiment of the present invention contemplates that in a cloud Computing environment can use the execution of a variety of application instances to realize the multi-tenant architecture, and repeatedly performs a data sharing for the plurality of instances in the application to save the memory of running the application.

The present invention, in one embodiment, provides a method for executing a plurality of instances of an application. From the description of the method processes, those skilled in the art will recognize that the method is applicable to all applications using object-oriented languages and executing on virtual machines, and there are many such applications, e.g. For example, Java language applications that can run on a Java virtual machine (JVM) machine, Ruby language applications that run on a Ruby virtual machine, and language applications "C #" that can be run on a C # virtual machine, etc.

1 illustrates the process of a method for executing a plurality of instances of an application according to an embodiment of the present invention. According to 1 In step S101, the execution of a root instance of the application is started, and the root instance includes at least one thread. Here, the root instance can be understood as the first execution of the application; In step S102, it is determined whether a thread of the root instance of the application comes to a glass transition point upon execution, which will be explained in detail below. If not, will continue to wait; if so, in step S103, in response to a thread of the root instance getting to a pre-determined application freeze point upon execution, execution of all threads of the root instance is halted; preferably, in step S104, an attribute of a root instance object in the root instance is designated as "read only", which only serves to prevent a subsequent write operation from modifying the root instance object; As will be apparent from the subsequent processing of the method, in the event that a write operation is involved, in fact, no operation of directly modifying a field of the root instance object takes place. Therefore, such labeling only serves to prevent misoperation and is a preferred implementation; In step S105, it is determined whether all threads of an instance of the application are to be executed, and here an instance is understood as the second, third ... execution of the application, ie, not first executing the application; if not, will continue to wait; if yes, in step S106, in response to starting execution of an instance of the application, the execution state of all threads of the root instance is replicated as the execution state of all threads of the instance; based on the replicated execution state of all threads, in step S107, all threads of the instance of the application are executed.

Compared with the realization of multi-client capability in which the JVM is replicated in the prior art, in the method described above, only the execution state of all threads of the root instance is replicated, and the granularity of replication is lower, and the replicated contents are less extensive, so that more program execution memory space is saved.

Further illustrated 2 exemplifies the method of executing a plurality of instances of an application by using the language Java as an example. Although the method using the Java language is described as an example, those skilled in the art will understand that it can be replaced by any other application that uses object-oriented language and executes on a virtual machine. In 2 the whole application is like a process and runs on the Java virtual machine, and the JVM itself can contain many threads. The JVM thread of 2 is merely exemplary and shows an execution environment of the following application. The application takes place under the multi-tenant architecture, and according to the above method, the execution on the Java virtual machine can be divided into two phases: the first phase is the execution of the root instance; according to 2 assume that an instance contains three threads and the first executes the root instance; Generally, an instance of an application is typically executed by a main thread. The main thread can create additional threads (ie, child threads), allowing the child threads to create their own child threads. The creation of these threads is controlled by the code written by programmers. When the execution is to some extent, all threads of the root instance are halted, which is called a "freeze point" here. According to one embodiment of the present invention, the freeze point indicates that all objects that could be shared by different clients have been initialized. The manner of specifying the glass transition point may be to invoke a specific instruction or function provided by the virtual machine. Usually only one single point of freezing has to be defined in a program, which is executed only once. When a thread of the program first reaches the freeze point when it is executed, the virtual machine receives the Call the special statement or function and then immediately begin executing the freeze operation, that is, suspending the execution of all threads from the application. The glass transition point is usually set by a programmer according to his knowledge of the program during the writing of the program and is within the program. Therefore, programs with the same functions written by different programmers can save different amounts of data storage due to different positions of the freezing point. In the future, with the advancement of technology and the development of artificial intelligence, the freezing point may, to a certain extent, be automatically determined by programming tools. When the freeze point is set automatically, the following principles can be used: at the freeze point, the number of local handles opened by all the threads of the root instance is at a minimum, and the number of active threads of the instance is minimal. Here, the local handles include file handles, network handles, and so on. When the root instance reaches the freeze point when run, all its threads are no longer running, and at this point, an attribute of a root instance object in the root instance may be designated as read-only, and then the execution state of all threads of the root instance in the root instance second stage as a replication foundation for executing all threads of other instances. There are many ways to identify a root instance object, for example: B. using a flag bit, in which case if the flag bit is 0, the attributes of all objects in the root instance are "read only", otherwise readable and writable, or using the type of locking, etc. In the second Phase starts running all threads of other instances; for executing all threads of a first instance, first the execution state of all threads of the root instance is replicated as the execution state of all threads of the instance, and the execution state of all threads is the data structure of all thread objects per se, including at least the current stack, the values of registers and count the current statement of a thread. The current stack of a thread can contain much information, including at least the reference to an instance object, and the reference can be a pointer that is referenced to a root instance object during initialization. In this way, the execution environment and the data of the root instance are over-replicated. Obviously, replicating the contents of the root instance has less granularity and less extensive content compared to replicating the execution environment of an application; In addition, this can further reduce the start time of a new instance. Thus, when the execution of a second and third instance begins, the execution state of all threads is still replicated from the root instance, and then they continue to execute.

During the execution process of all the threads of an instance, an access operation, which includes a read operation and a write operation, may be performed on a field of an object in a thread, and here a write operation is considered first. 3 shows a process that an instance performs a write operation. According to 3 at step S301, a write operation to a field of an instance object of the application is received; In step S302, it is determined whether the write operation is a first write operation to the instance object. Because the reference to the instance object in the current stack of the thread is initialized as referencing a root instance object prior to the first write operation, if it is determined to be the first write operation, that is, in response to the reference to the instance object referencing a root instance object, in step S303, a data storage area is allocated for the instance object; in step S304, the reference to the instance object contained in the current stack is referenced to the data storage area associated with the instance object; In step S305, the write operation is executed in the memory area. If it is determined in step S302 that the write operation is not the first write operation to the instance object, which means that the reference to the instance object contained in the current stack no longer referred to a root instance object but to the data storage area associated with the instance object that is, in response to the reference to the instance object not referencing a root instance object, it jumps directly to step S305.

A read performed on a field of an object in the thread can directly access the area to which the reference to the instance object contained in the current state of execution of all threads of the instance refers; if no write operation has been performed, the value of the field of the root instance object is read; when a write operation has been performed, the value of the field of the object is read in the data storage area associated with the instance object.

As can be seen from the above solution, by using the above access operation, the data storage space occupied by attributes of an instance object, ie data, is further reduced; if there is no data update, ie no write to an attribute of an instance object happens, all will Read operations are directed to attributes of a root instance object, and there is no need to replicate the attributes of instance objects, and the data storage space can be further reduced.

4 Figure 15 shows another process that an instance is performing a write operation. According to 4 at step S401, a write operation to a field of an instance object is received; In step S402, it is determined whether a corresponding field of a root instance object referenced by the reference to the root instance object is flagged as not yet performing a write operation, and in response to a corresponding field of a root instance object referenced by the reference to Instance object referenced as having not yet performed a write operation, in step S403, a data storage area for the field of the instance object associated with the write operation is assigned; In this way, no data storage area for an entire object as in the 3 associated realization, and it is assigned only a data storage area for the field that needs to be modified in the object. The field in the object represents only a small part of the object, and the occupied data storage space is much smaller than the data storage space occupied by the objects, and thus this can further save the data storage space of the instance; in step S404, the corresponding field of the root instance object referenced by the reference to the instance object is designated as having performed a write operation; In step S405, the write operation is performed in the associated data storage area. Such labeling can be done in many ways, for. For example, using different values of a variable to indicate different meanings, or using the virtual machine to identify, and so on. If the corresponding field of the root instance object referenced by the instance instance object instance is identified as performing a write operation which means that a data storage area has been assigned to the field of the instance object associated with the write operation, at this time in step S406 in response to the corresponding field of the root instance object referenced by the reference to the instance object being so marked in that it has performed a write operation, and the write operation is performed in the data storage area associated with the field of the instance object associated with the write operation.

A read performed in a field of an object in the thread can directly access the area to which the reference to the instance object contained in the current state of execution of the thread of the instance refers; if no write operation has been performed, the value of the field of the root instance object is read; if a write operation has been performed, the field of the instance object would have been flagged, and such information stored in the virtual machine could be used to read out the value of the field of the object in the data storage area associated with the field of the instance object.

Obviously, this realization not only further saves the data storage space of an instance, but also brings all the advantages of the embodiment of 3 with himself.

When execution of the application is halted, not only the execution of all other instances is halted to clear the program execution space and the data storage space occupied by all instances, but the executable space occupied by the root instance and the data storage space are also freed.

Under the same inventive concept, in one embodiment of the present invention, there is also disclosed a system for executing a plurality of instances of an application. 5 Fig. 12 schematically shows a structural block diagram of a system for executing a plurality of instances of an application. As in 5 the system comprises: a root instance launcher 501 that is set up to start executing a root instance of the application, the root instance including at least one thread; a root instance stopping means 502 set up, in response to a thread of the root instance, when executed, arriving at a predetermined freeze point in the application to halt the execution of all threads of the root instance; a replicating agent 503 configured to, in response to starting execution of an instance of the application, replicate the execution state of all threads of the root instance as the execution state of all the threads of the instance; and an execution continuation means 504 which is set up to continue running all the threads of the instance of the application. In a preferred embodiment, the system further comprises a root instance object identifier 505 configured to flag an attribute of a root instance object in the root instance as "read only" in response to a thread of the root instance, when executed, arriving at a predetermined freeze point in the application; In the system, the execution state of the thread includes at least the current stack, the values of registers, and the current instruction of the thread. The current batch of execution state A thread of a system instance contains a reference to an instance object, whereby the reference to the object instance is initialized as referring to the root instance object.

In one embodiment, the execution continuation means further comprises: a write operation receiving means arranged to receive a write operation on a field of an instance object; memory allocation means arranged in response to the reference to the instance object received by the write operation receiving means referring to a root instance object to allocate a data storage area for the instance object; a reference modifier configured, in response to the reference to the instance object received by the write operation receiving means referencing a root instance object, to refer the reference to the instance object to the data storage area associated with the data storage area allocation means; write operation executing means arranged in response to the reference to the instance object received by the write operation receiving means referring to a root instance object to execute the write operation in the data storage area allocated by the data storage area allocation means. Here, the write operation executing means is further arranged in response to the reference to the instance object received by the write operation receiving means not pointing to the root instance object to execute the write operation in the data storage area allocated by the data storage area allocation means.

In another embodiment, the execution continuation means further comprises: a write operation receiving means arranged to receive a write operation to a field of an instance object; a flag set up, in response to the corresponding field of the root instance object to which the reference received by the write operation receiving means refers to the instance object being characterized as not yet executing a write operation, the corresponding field of the root instance object to flag that it has performed a write operation; a data storage area allocation means arranged in response to the corresponding field of the root instance object to which the reference received by the write operation receiving means refers to the instance object being characterized as having not yet performed a write operation, a data storage area for the Assign the field of the instance object; a write operation executing means arranged in response to the corresponding field of the root instance object to which the reference received by the write operation receiving means refers to the instance object being characterized as having not yet executed a write operation, the write operation in the execute data storage area associated with the data storage area allocation means. In the system, the write operation execution means is further arranged in response to the corresponding field of the root instance object to which the reference received by the write operation receiving means refers to the instance object being designated to have performed a write operation, the write operation in the execute data storage area associated with the data storage area allocation means.

While the exemplary embodiments of the present invention have been described herein with reference to the accompanying drawings, it should be understood that the present invention is not limited to these precise embodiments and that those skilled in the embodiments can make various changes and modifications without departing from the scope of the invention To depart from the scope and objectives of the present invention. All such changes and modifications are intended to be included within the scope of the present invention as defined in the appended claims.

Moreover, those skilled in the art will appreciate that the present invention may be embodied as devices, methods, or computer program products. Therefore, the present invention may be particularly in the following forms, i. H. completely hardware, completely software (including firmware, resident software, microcode, etc.) or a combination of software part and hardware part, which is generally referred to herein as "circuit," "module," or system. Moreover, the present invention may be in the form of a computer program product embodied in any of the subject execution media in which computer-usable program code is included.

Any combination of one or more computer-readable or computer-usable media may be used. The computer-readable or computer-usable medium may be, but is not limited to, a system, device, unit, or propagation medium of electronic, magnetic, optical, electromagnetic, or infrared or semiconductor-use type. More specific examples (non-exhaustive list) of the computer readable medium include: an electrical connection to a computer or multiple lines, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an electrically programmable read-only memory ( electrically programmable read-only memory (EPROM or flash memory), an optical fiber, a portable read-only compact disk (CD-ROM), an optical storage unit, a transmission medium supporting the Internet or an intranet, or It is to be noted that the computer-readable or computer-usable medium may also be a paper with programs printed thereon or other suitable media, this is because, for example, the program is electrically powered by electric power Scanning this type of paper or other media obtained and compiled, interpreted or processed in an appropriate manner and, if necessary, in ei a computer memory can be stored. In the context of this document, a computer-readable or computer-usable medium may be any medium that can contain, store, deliver, send, or transmit programs for use by or in connection with an instruction execution system, apparatus, or device. The computer readable medium may include data signals having computer readable program code contained therein and distributed in baseband or as part of a carrier wave. The computer readable program code may be transmitted by any suitable means including, but not limited to, wireless, wired, optical fiber cables, RF, etc.

The computer program code for performing operations of the present invention may be written in any combination of one or more programming languages, including object-oriented programming languages such as Java, Smalltalk, C ++ or similar and conventional procedural programming languages such as the "C" programming language or similar programming languages. The program code may be executed entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on a remote computer or server. In the latter scenario, the remote computer may or may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN) Connecting to an external computer (for example, via an Internet service provider via the Internet) are made.

Moreover, each block of the flowchart and / or block diagrams as well as combinations of blocks in the flowchart and / or block diagrams of the present invention may be implemented by computer program instructions. These computer program instructions may be provided to a general purpose computer processor, a dedicated computer, or other programmable data processing device to generate a machine such that the instructions that are executed via the processor of the computer or other programmable data processing device provide means for realizing the computer Create functions / actions specified in the block or blocks of the flowchart and / or block diagram.

These computer program instructions may also be stored in a computer-readable medium that may direct a computer or other programmable computing device to function in a particular manner so that the instructions stored in the computer-readable medium produce a manufactured article including an instruction resource corresponding to that in block or performs functions / actions specified in the blocks in the flowcharts and / or block diagrams.

The computer program instructions may also be loaded onto a computer or other programmable data processing device to cause a series of operations to be performed on the computer or other programmable device to generate a process implemented on the computer such as that on the computer or the other instructions provide a process for realizing the functions / actions specified in the block or in the blocks in the flowcharts and / or block diagrams.

The flowcharts and block diagrams in the figures illustrate the architectures, functionality, and operations of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagram may represent a module, segment, or code section having one or more executable instructions for implementing the specific logical function (s). It should also be noted that in some alternative implementations, the functions specified in the blocks may occur in a different order than that indicated in the figures. For example, two consecutively mapped blocks actually be executed substantially concurrently, or the blocks may sometimes be executed in reverse order depending on the functionality involved. It is also noted that each block of the block diagrams and / or the schedule and combinations of blocks in the block diagrams and / or the mapping of schedules may be realized by dedicated hardware-based systems or combinations of dedicated hardware and computer instructions having the stated functions or acts carry out.

QUOTES INCLUDE IN THE DESCRIPTION

This list of the documents listed by the applicant has been generated automatically and is included solely for the better information of the reader. The list is not part of the German patent or utility model application. The DPMA assumes no liability for any errors or omissions.

Cited patent literature

• US 7426720 [0007]
• US 4742450 [0008]
• US 7536525 [0009]
• US 7657888 [0010]
• WO 2007/036072 [0011]
• US 2010/0223613 [0012]
• US 7421698 [0013]

Cited non-patent literature

• "Cloneable JVM: A New Approach to Starting Java Applications Faster" by Kawachiya, Ogata, Silva, Hideaki, Nakatani [0014]

Claims (17)

A method of executing a plurality of instances of an application, the method comprising: Starting execution of a root instance of the application, wherein the root instance includes at least one thread; in response to a thread of the root instance, when executed, arriving at a predetermined freeze point in the application, stopping execution of all threads of the root instance; in response to starting execution of an instance of the application, replicating the execution state of all threads of the root instance as the execution state of all threads of the instance; and Continue with running all the threads of the instance of the application. The method of claim 1, wherein the execution state includes at least: the current stack, the values of registers, and the current instruction of a thread. The method of claim 2, wherein the current state of execution of the execution state includes a reference to an instance object in the instance, wherein the reference to the instance object is initialized to refer to the root instance object. The method of claim 3, wherein continuing to execute all threads of the instance of the application comprises: Receiving a write operation on a field of an instance object; in response to a reference to the instance object referring to a root instance object: Allocating a data storage area for the instance object; Pointing the reference to the instance object to the data storage area; Perform the write operation in the data storage area. The method of claim 4, wherein the method further comprises: in response to the reference to an instance object not pointing to a root instance object, performing the write operation in the data storage area referenced by the reference to the instance object. The method of claim 3, wherein continuing to execute all threads of the instance of the application comprises: Receiving a write operation on a field of an instance object; in response to a corresponding field of a root instance object referenced by the reference to the instance object being flagged as not yet performing a write operation: Allocating a data storage area for the field of the instance object; Identifying the corresponding field of the root instance object to have performed a write operation; Perform the write operation in the data storage area. The method of claim 6, further comprising: in response to a corresponding field of a root instance object referenced by the reference to the instance object being characterized as having performed a write operation, performing the write operation in the data storage area associated with the field of the instance object associated with that write operation is. The method of claim 1, further comprising: in response to a thread of the root instance arriving in execution at a predetermined freeze point in the application, flagging an attribute of a root instance object in the root instance as read-only. A system for executing a plurality of instances of an application, the system comprising: a root instance launcher arranged to start executing a root instance of the application, the root instance including at least one thread; a root instance suspending means, arranged in response to a thread of the root instance, when executed, arriving at a predetermined freezing point in the application to halt the execution of all threads of the root instance; a replicating means arranged to replicate, in response to starting to execute an instance of the application, the execution state of all threads of the root instance as the execution state of all the threads of the instance; and execution execution means arranged to continue to execute all the threads of the instance of the application. The system of claim 9, wherein the execution state includes at least: the current stack, the values of registers, and the current instruction of a thread. The system of claim 10, wherein the current state of execution of the execution state includes a reference to the instance object in the instance, wherein the reference to the instance object is initialized to refer to a root instance object. The system of claim 11, wherein the execution continuation means comprises: a write operation receiving means arranged to receive a write operation to a field of the instance object; data storage allocation means arranged to, in response to a reference to the instance object referencing the root instance object, allocate a data storage area for the instance object; a reference modifier configured to, in response to a reference to the instance object received by the write operation receiving means refering to the root instance object, refer the reference to the instance object to the data storage area associated with the data storage area allocation means; write operation executing means arranged in response to the reference to the instance object received by the write operation receiving means referring to the root instance object to execute the write operation in the data storage area allocated by the data storage area allocation means. The system of claim 12, wherein the write operation executing means is further arranged, in response to the reference to the instance object received by the write operation receiving unit, not pointing to the root instance object to execute the write operation in the data storage area allocated by the data storage area allocation means. The system of claim 11, wherein the execution continuation means comprises: a write operation receiving means arranged to receive a write operation on a field of the instance object; a flag set up in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object being characterized as not yet executing a write operation; the corresponding field of the root instance object so to flag that it has performed a write operation; a data storage area allocation means arranged to designate, in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object, that it has not yet performed a write operation, a data storage area for Assign the field of the instance object; a write operation executing means arranged in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object being characterized as not yet executing a write operation, the write operation in the execute data storage area associated with the data storage area allocation means. The system of claim 14, wherein the write operation executing means is further arranged in response to a corresponding field of a root instance object to which the reference received by the write operation receiving means refers to the instance object being designated to execute a write operation. execute the write operation in the data storage area allocated by the data storage area allocation means. The system of any one of claims 9 to 15, wherein the system further comprises: a root instance object identifier arranged to flag an attribute of the root instance object in the root instance as "read only" in response to a thread of the root instance, when executed, arriving at a predetermined freeze point in the application; A computer program comprising program code means adapted to perform the method of any one of claims 1 to 8 when the program is run on a computer.

Images