JP2009512030A - Duplicate object graph - Google Patents

Abstract

At least one application program (50) includes a plurality of computers M1, M2,. . . . An update of only a few memory locations in a multi-computer environment running concurrently on Mn is disclosed. In each local memory, objects A and B each containing a primitive field (11) are disclosed. However, simultaneous operation of the application program (50) can result in a “non-primitive” reference field (10) on one machine that must be later replicated to all other machines. However, the reference field (10) refers to another object (H) in the local memory of one machine, thus creating a corresponding object (T, K) in the local memory of each machine, Must be referenced by the corresponding non-primitive field (10).
[Selection] Figure 6

Description

  The present invention relates to computer processing, and in particular, to the simultaneous operation of multiple computers interconnected via a communication network.

  In the international patent application number PCT / AU2005 / 000580 (Attorney Docket No. 5027F-WO) published in WO 2005/103926 (corresponding to US patent application No. 11 / 111,946 and publication number 2005-0262313) in the name of the present applicant Discloses how different portions of an application program that are described to run only on a single computer can run on corresponding different computers of the plurality of computers at substantially the same time. This simultaneous operation is not commercially used as of the priority date of this application. "Computer Architecture Method of Operation for Multi-Computer Distributed Processing and Co-Organized Memory and Asset Handling" Patent Methodology for the United States: "Computer-Architecture Method for Memory and Asset Processing" PCT / AU2006 / 000532 in the international patent application number PCT / AU2005 / 001641 (Attorney Docket No. 5027F-D1-WO) to which 11/259985 corresponds and in the name of the applicant not published on the priority date of this application (Attorney Docket No. 5027F-D2-WO) is also disclosed in more detail. The contents of each specification of the above prior applications are incorporated herein by cross-reference for all purposes.

  Briefly stated, in the above-mentioned patent specification, at least one application program written to run only on a single computer runs simultaneously on several computers, each with independent local memory. It is disclosed that it can be done. The memory location required for the operation of this program is replicated to an independent local memory on each computer. Each time an application program writes new data to any replicated memory location, the new data is transmitted and stored in each corresponding memory location on each computer. Thus, apart from the possibility of transmission delay, each computer has a local memory whose contents are updated to be substantially the same as and maintain each other's computer's local memory. Since all application programs generally read data much more frequently than new data is written, the above arrangement allows a significant advantage in computer processing speed to be achieved. In particular, these measures allow two or more general purpose computers interconnected by a commodity communication network to run and operate simultaneously under an application program written to run only on a single computer. Is possible.

  JAVA (registered trademark) and MICROSOFT. Higher level languages including NET have two types of memory locations or fields. These first types are so-called “primitive” fields and contain alphanumeric data such as numbers or letters. This content is easily duplicated by simply copying it to another primitive field. The second type of field is a “non-primitive” field, commonly referred to as a reference field, which essentially contains a “pointer” to another memory location or another object. Programming languages use one or more pointers to redirect computer operation to a reference address. If the pointer is copied in a mimicry, it will point to the same memory location on other machines, but these locations may or may not have the same memory content. .

  The root of the present invention is a requirement that facilitates the duplication of non-primitive fields in a multi-computer system, thereby making it as close as possible to the desired goal of substantially the same memory structure and content.

According to a first aspect of the present invention, different portions of at least one application program are copied in a multi-computer environment that is executed simultaneously on different computers of a plurality of computers interconnected via a communication network. A method for replicating a non-primitive field of an object is disclosed, the method comprising:
(I) creating a concordance table and, for each object present in any one of the plurality of computers, correlating an entry in the concordance table with each reference to the object;
(Ii) Each entry in the concordance table contains a local pointer to a local memory object referenced by an object on one machine and either replicates the concordance table on each computer or exists in the server computer Allowing each computer to access the corresponding part of a single concordance table for all machines;
(Iii) causing each other machine to specify a corresponding non-primitive field and a local object, and entering a corresponding local pointer of the corresponding local memory object into one or more tables.

  According to a second aspect of the present invention, there is disclosed a multi-computer system in which different parts of at least one application program are executed simultaneously on different computers of a plurality of computers interconnected via a communication network, For each non-primitive field created on any one of the computers, there is a corresponding entry in the concordance table that is accessible by all computers or replicated to each computer, and the table entry is a non-primitive of one computer Contains a local pointer to the local memory object referenced by the field, and the computer specifies each other a corresponding non-primitive field and a local object, and a corresponding local memory Corresponding local pointer Li object is input to one or more of concordance tables.

  According to a third aspect of the present invention, there are disclosed a plurality of computers interconnected via a communication network and operable to reliably perform the above method.

  According to a fourth aspect of the invention, there is disclosed a computer program product comprising a set of program instructions stored in a storage medium and operable to allow a plurality of computers to perform the above method.

  According to a fifth aspect of the invention, there is provided a single computer adapted to cooperate with at least one other computer to perform the above method or form the above computer system. Disclosed.

  Although embodiments will be described in relation to the JAVA® language, the present invention is not limited to this language, and in particular, MICROSOFT. Can be used with other languages (including procedural, declarative, and object-oriented languages), including NET platforms and architectures (Visual Basic, VisualC, VisualC ++, and VisualC #), FORTRAN, C, C ++, COBOL, BASIC, and the like Will be apparent to those skilled in the art.

  A single computer or machine that utilizes a particular language of an application by creating a virtual machine as shown in FIG. 1A (an operating system created by any of a variety of manufacturers and operating in any of a variety of different languages Providing a system (or equivalent control software or other mechanism) is known in the prior art.

  The code and data and virtual machine settings or configuration of FIG. 1A take the form of application code 50 written in the JAVA® language and executed within the JAVA® virtual machine 61. Therefore, if the target language of the application is JAVA® language, a JAVA® virtual machine that can operate JAVA® code regardless of the machine manufacturer and the details inside the computer or machine. Is used. For further details, see US Sun Microsystems Inc., which is incorporated herein by reference. T. Lindholm and F.M. See “The JAVA® Virtual Machine Specification” 2nd Edition (JAVA® virtual machine specification) 2nd edition by Yellin.

  This prior art configuration of FIG. 1A is in accordance with an embodiment of the present invention by providing an additional function referred to as a “distributed runtime” or “distributed runtime system” DRT 71 for convenience, as seen in FIG. 1B. Will be corrected.

  In FIGS. 1B and 1C, the application code 50 cooperates with the distributed runtime system 71 via a load process indicated by arrows 75 or 75A or 75B, and Java virtual machines M1, M2,. . . Loaded into Mn. As used herein, the terms “distributed runtime” and “distributed runtime system” are synonymous in nature and are described by way of illustration and not limitation in a particular language running on a particular platform. It is generally understood to include library code and processes that support the configured software. In addition, the distributed runtime system can also include library code and processes that support software written in a particular language running within a particular distributed computing environment. A runtime system (whether or not a distributed runtime system) typically handles the details of the interface between the program and the operating system, such as system calls, program startup and termination, and memory management. . For background purposes, a conventional distributed computing environment (DCE) (which does not provide the functionality of the distributed runtime or distributed runtime system 71 of the present invention used in the preferred embodiment of the present invention) is Open Software Foundation. Is available from Although this distributed computing environment (DCE) implements a form of computer-to-computer communication for software running on a machine, it cannot perform the necessary modifications or communication operations, among many limitations. Among its functions and operations, the preferred DRT 71 includes a plurality of machines M1, M2,. . . Coordinate specific communication between Mn. In addition, the preferred distributed runtime 71 includes each JAVA virtual machine 72 or machine JVM # 1, JVM # 2,. . . Operation is entered during the load process indicated by arrow 75A or 75B of JAVA application 50 on JVM # n. Although many embodiments and descriptions are provided for the JAVA® language and JAVA® virtual machine so that the reader can benefit from the specific embodiments, the present invention provides a Java It is understood in light of the description presented herein that it is not limited to either a registered language or JAVA virtual machine, or any other language, virtual machine, machine or operating environment. Will.

  FIG. 1C shows the configuration of the JAVA® virtual machine, each shown in FIG. 1B, in a modified form. Also in this case, the same application code 50 is assigned to each machine M1, M2,. . . It will be apparent that Mn is loaded. However, each machine M1, M2,. . . Communication between Mn is physically routed through the machine hardware, but the individual DRTs 71/1. . . It is advantageously controlled by 71 / n. Therefore, in practice this means that the machines M1, M2. . . DRTs 71/1,... That communicate with each other via a network or other communication link 53 instead of Mn. . . It can be conceptualized as 71 / n. Machine M1, M2. . . Mn or DRT 71/1, 71/2. . . Either this direct communication between 71 / n or a combination of such communications is contemplated and included. The preferred DRT 71 provides transport, protocol, and link independent communication.

  One common application program or application code 50 and its executable version (possibly modified) may be stored in a plurality of computers or machines M1, M2,. . . The entire Mn is executed simultaneously or in parallel. Application program 50 is described to run on a single machine or computer (or to run on the multi-computer system of the above-mentioned patent application that emulates a single computer operation). In essence, the modified structure duplicates the same memory structure and content on each individual machine.

  The term “common application program” is written to run on a single machine and includes a plurality of computers or machines M1, M2,. . . Mn in whole or in part, or optionally a plurality of computers or machines M1, M2. . . It should be understood to mean an application program or application program code that is loaded and / or executed on each subset of Mn. In other words, there is a common application program represented in the application code 50. This is either a single copy or multiple identical copies, each individually modified to produce a modified copy or version of the application program or program code. Each copy or instance is then ready to run on the corresponding machine. At a point after they have been modified, they are common in that they perform similar operations and operate to be consistent and consistent with each other. Optionally, a plurality of computers, machines, information appliances, or the like that implement embodiments of the present invention, other computers, machines, information appliances, or the like that do not implement embodiments of the present invention It will be understood that it can be connected or coupled to things.

  The same application program 50 (eg, a parallel merge sort, or computational fluid dynamics application, or data mining application) is run on each machine, but the executable code for that application program is run on each machine as needed. Modified, each execution instance (copy or duplicate) on each machine coordinates the operation of the respective instance (or copy or duplicate) on the other machine with the local operation on that particular machine, which is consistent It works together in a coordinated manner that is consistent and consistent, and appears to be one global instance of an application (ie, a “meta-application”).

  Each copy or duplicate of the same or substantially the same application code is loaded into a corresponding computer of the interoperating and connected machine or computer. Because the characteristics of each machine or computer can be different, the application code 50 can be modified before loading or during the loading process, or modified after the loading process, with some drawbacks, on each machine. A customized or modified version of the application code can be provided. Any differences between the programs or application code on the various machines can be tolerated as long as other requirements for interoperability, consistency, and consistency described herein can be maintained. As will become apparent below, the machines M1, M2. . . Mn, and in other words, the machines M1, M2. . . All of the Mn have the same or substantially the same application code 50, usually with modifications that can be machine specific.

  Each machine M1, M2. . . At any point before or during loading of application code 50 (or related parts) on Mn, or before execution, each application code 50 has the same rules (or slight optimization changes for each modifier 51). / 1, 51/2... 51 / n so that it is modified by the corresponding modifier 51 according to substantially the same rule).

  Machine M1, M2. . . Each Mn is implemented as the same (or substantially the same or similar) modifier 51 (in some embodiments, as a distributed runtime or DRT 71, in other embodiments, attached to application code and data 50) And can be implemented in a JAVA virtual machine itself). Accordingly, the machines M1, M2. . . All of the Mn have the same (or substantially the same or similar) modifier 51 for each modification required. For example, other modifications may be required for memory management and replication, for initialization, for finalization, and / or for synchronization (although in all embodiments these modifications may be required) Not all types are required).

  There are other implementations of modifier 51 and distributed runtime 71. For example, as indicated by the dashed line in FIG. 1C, the modifier 51 can be implemented as a component of or within the distributed runtime 71, so that the DRT 71 performs the functions and operations of the modifier 51. Can do. Alternatively, the functions and operations of the modifier 51 are external to the structure, software, firmware, or other means used to implement the DRT 71, such as in the code and data 50, or in the JAVA virtual machine itself. Can be implemented. In one embodiment, both modifier 51 and DRT 71 are implemented or described in a single computer program code that provides DRT and modifier functionality. In this case, the modifier function and structure are actually included in the DRT. Regardless of how it is implemented, modifier functions and structures are responsible for modifying the executable code of application code programs, and distributed runtime functions and structures perform communication between computers or machines. Take a role. The communication functions in one embodiment are implemented through an intermediate protocol layer in the DRT computer program code on each machine. The DRT can implement a communication stack, for example, in the JAVA language, and can provide communication or call between machines using Transmission Control Protocol / Internet Protocol (TCP / IP). These functions or operations may be implemented in a variety of ways, and in view of the description provided herein, these functions or operations may be between structures and / or procedural elements, or computer program code or data structures. It will be appreciated that the exact implementation or division in between is not critical to the invention and is not essential.

  However, in the configuration shown in FIG. 1, a plurality of individual computers or machines M1, M2,. . . Mn is provided, each of which is interconnected via communication network 53 or other communication link. Each individual computer or machine has a corresponding modifier 51. Each individual computer also includes a communication port that connects to a communication network. The communication network 53 or path can be any electronic signaling, data, or digital communication network or path, including network connection over the Internet, or ETHERNET® or INFINIBAND and extensions and improvements thereof. A low speed and thus low cost communication path is preferred, such as some common network configuration. Preferably, the computer has one or more known communication ports (such as CISCO Power Connect 5224 Switch) that connect to the communication network 53.

  As a result of the above configuration, the machines M1, M2,. . . , Mn each has, for example, 10 MB of internal or local memory capacity, the total memory available to the application code 50 as a whole is not the number of machines (n) × 10 MB as expected. This is not an additive combination of the internal memory capacity of all n machines. Rather, it is 10 MB, or some number that is larger than 10 MB but smaller than n × 10 MB. This is acceptable if the internal memory capacity of the machine is different, and thus if the internal memory capacity of one machine is smaller than the internal memory capacity of at least one other machine of the machine, A small memory size allows such memory (or a portion thereof) to be treated as “common” memory (ie, similar equivalent memory for each of the machines M1... Mn) or to execute common application code. Can be used as the maximum memory capacity of the machine.

  However, the way in which each machine's internal memory is processed may initially be a potential performance constraint, but it will become clear below what improved operation and performance this will bring. Will. Of course, each machine M1, M2. . . Mn has a private (ie, “non-common”) internal memory capacity. Machines M1, M2,. . . , Mn's private internal memory capacity is usually approximately equal, but not required. For example, if a multi-computer system is implemented or organized using existing computers, machines, or information appliances owned or operated by different entities, the internal memory capacity may be quite different. On the other hand, if a new multi-computer system is implemented, each machine or computer is preferably selected to have the same internal memory capacity, but this is not required.

  It should be understood that each machine's independent local memory represents only that portion of the machine's total memory allocated to that portion of the application program running on that machine. Thus, other memory is occupied by the machine's operating system and other computing tasks unrelated to the application program 50.

  Non-commercial operation of a prototype multi-computer system indicates that every machine or computer in the system does not use or need to reference every possible memory location (eg, having its local replica). As a result, as long as the local memory of each machine is sufficient for the operation of the machine, the multicomputer system can be operated without any other machine having the same local memory of each machine. That is, if a particular machine does not need to reference some particular memory location (eg, having its local replica), it does not matter that that particular memory location is not replicated on that particular machine.

  Also, a plurality of machines, computers or information appliances M1, M2,. . . , It may be advantageous to select the amount of internal memory for each machine to achieve the desired level of performance across the Mn constellation or network. In view of these described internal and common memories, it will be apparent in light of the description provided herein that there is no limit to the amount of memory that can be common between machines.

  In some embodiments, some or all of a plurality of individual computers or machines may be a single housing or chassis (a so-called “blade server” manufactured by Hewlett-Packard Development Company, Intel Corporation, IBM Corporation, etc.). Or a multiprocessor (eg, symmetric multiprocessor or SMP) or multicore processor (eg, symmetric multiprocessor or SMP) manufactured by Intel, AMD, or others, or implemented in a single printed circuit board or a single chip or chipset , Dual core processor and chip multithreading processor). Similarly, a computer or machine having a multi-core, multi-CPU, or other processing logic is included.

  When implemented in a non-Java® language or application code environment, a generalized platform and / or virtual machine and / or machine and / or runtime system may be the platform and / or virtual machine and / or machine. And / or the language of the runtime system environment (e.g., without limitation, any one of the source-code language, intermediate-code language, object-code language, machine-code language, and any other code language or The application code 50 may run on the platform and / or virtual machine and / or machine and / or runtime system and / or language regardless of the machine or processor manufacturer and internal details of the machine It is possible to use the architecture. It will be appreciated that the platform and / or runtime system may include virtual and non-virtual machine software and / or firmware architecture, and hardware and direct hardware coding applications and implementations.

  Do not use or use any of the classes and / or objects in a more general set of virtual or abstract machine environments and in current and future computers and / or computer machines and / or information appliances or processing systems Although not required, the structure, method, and computer program and computer program product of the present invention are still applicable. Examples of computers and / or computer machines that do not utilize either classes and / or objects include, for example, x86 computer architecture manufactured by Intel Corporation and others, SPARC computer architecture manufactured by Sun Microsystems, Inc and others. And Power PC computer architecture manufactured by International Business Machines Corporation and others, and personal computer products manufactured by Apple Computer, Inc and others.

  In these types of computers, computer machines, information appliances, and virtual machines or virtual computer environments implemented without using the concept of classes or objects, for example, a basic data type (integer for procedural languages or other languages) Data types, floating point data types, long data types, double data types, string data types, character data types, and Boolean data types), structured data types (such as arrays and records), derived types, or other codes or Contains data structures and can be generalized to include environments such as functions, pointers, components, modules, structures, references, and unions. These structures and procedures applied in combination when needed may require a memory location, address range, object, class, asset, resource, or any other procedure or structural aspect of the computer or computing environment. In some cases, a plurality of individual machines M1, M2. . . Maintain a computing environment that is coordinated across Mn, created, maintained, operated, and deactivated or deleted in a consistent and consistent manner.

  This analysis or scrutiny of the application code 50 can also be performed before the application program code 50 is loaded, during the application program code 50 loading process, or after the application program code 50 loading process (or some combination thereof). This is because the application code comprises additional instructions and / or is otherwise modified by semantic protection program manipulation and / or optionally translated from the input code language to a different code language (eg source It can be described as instrumentation, program conversion, translation, or compilation procedures in that it can be converted from a code language or an intermediate-code language to an object-code language or machine-code language. In this context, it is understood that the term “compile” usually or conventionally encompasses changes in code or language, such as changes from source code to object code or from one language to another. However, in the present invention, the term “compile” (and its grammatically equivalent phrases) is not limited to this, and can include or include modifications within the same code or language. For example, compilation and its equivalent phrases include normal compilation (eg, by way of example and not limitation, source-code to object code, etc.), source-code to source-code compilation, and object-code to object. It is understood to encompass compilation into code and any modified combinations. Also included are so-called “intermediate-code languages” in the form of “pseudo-object-code”.

  By way of example and not limitation, in one embodiment, the analysis or review of application code 50 is such that the operating system reads application code 50 from a hard disk or other storage device, media, or source and copies it to memory for application This is done during loading of the application program code, such as by preparing to start executing the program code. In another embodiment, in a JAVA® virtual machine, the analysis or scrutiny is Java®. lang. ClassLoader. It can be performed during the class loading process of the loadClass method (for example, “java (registered trademark). lang. ClassLoader.loadClass ()”).

  Alternatively or in addition, analysis or review of application code 50 (or a portion of application code) may be performed after application program code loading processing, such as after the operating system has loaded application code into memory, or For example, after the JAVA® virtual machine has loaded the application code into the virtual machine via the “java®.lang.ClassLoader.loadClass ()” method and optionally initiated execution Alternatively, it can be performed even after execution of the corresponding part of the application program code is activated.

  Those skilled in the computer arts will recognize various possible techniques that can be used to modify computer code, including but not limited to instrumentation, program conversion, translation, or compilation means and / or methods. Will be.

  One such technique is to make modifications to the application code without any previous or resulting change in the language of the application code. Another such technique is to convert original code (eg, JAVA language source-code) into an intermediate representation (or intermediate-code language, or pseudocode) such as JAVA® bytecode. It is. When this conversion is performed, the bytecode is modified so that the conversion can be reversed. This yields the desired result of the improved JAVA code.

  Another possible technique is to convert the application program into machine code either directly from source-code or via the aforementioned intermediate language or via some other intermediate means. The machine code is then modified before loading and execution. Yet another such technique is to modify the original code into an intermediate representation that is then converted to machine code.

  The present invention also encompasses all such modified routes and combinations of two, three or more such routes.

  The DRT 71 or other code modifying means can be used for each machine M1, M2,. . . Responsible for creating or replicating the memory structure and content for each of Mn, thereby enabling interoperability of multiple machines. In some embodiments, this replicated memory structure is the same. In other embodiments, the memory structure will have portions that are identical and other portions that are not identical. In yet other embodiments, the memory structure differs only in format or storage convention, such as Big Endian or Little Endian format or convention.

  These structures and procedures that are applied in combination when needed are memory locations, address ranges, objects, classes, assets, resources, or any other procedure or structural aspect of a computer or computing environment Includes a plurality of individual machines M1, M2. . . Maintain a computing environment that is coordinated across Mn, created, maintained, operated, and deactivated or deleted in a consistent and consistent manner.

  Thus, the terms “one”, “single”, and “common” application code or program refer to all machines M1, M2,. . . Running or executing the same program or code rather than different (and unrelated) programs of Mn, in other words, copies or copies of the same or substantially the same application code are interoperable and connected machines or Includes the situation loaded on each of the computers.

In conventional configurations utilizing distributed software, memory access from one machine's software to memory physically located on another machine is typically performed via a network interconnecting the machines. Thus, the local memory of each machine can be accessed by any other machine and is therefore not independent. However, read and / or write memory access to memory physically located on another computer requires the use of a slow network interconnecting the computers, so in these configurations such an Memory access can cause significant delays in memory read / write processing operations, potentially on the order of 10 ⁶ -10 ⁷ cycles of the machine's central processing unit (assuming the latest processor speed). . Ultimately, this delay depends on a number of factors, such as the speed, bandwidth, and / or latency of the communication network. This is mainly responsible for the performance degradation of multiple interconnected machines in prior art configurations.

  However, in this configuration, the current value of all memory locations (or a subset thereof) is stored on the machine executing the process that causes the memory read request, so that all reads of memory locations or data are local. Filled with.

  Similarly, since the current values of all memory locations (or a subset thereof) are stored on the machine that performs the process that produces the memory write request, all writes of the memory location or data are satisfied locally. .

Such local memory read and write processing operations are typically satisfied within 10 ² -10 ³ cycles of the central processing unit. Thus, in practice, there is much less waiting for memory access for inclusion and / or writing. Also, the local memory of each machine cannot be accessed by any other machine and is therefore independent.

  The present invention is independent of transport, network, and communication paths and does not depend on how communication between machines or DRTs is performed. In one embodiment, an electronic mail (Email) exchange between machines or DRTs may be sufficient for communication.

  In connection with the above, the machine program M1, M2,..., Which is an integer greater than or equal to 2, the application program 50 of FIG. . . It can be seen from FIG. 2 that there is a number “n” of Mn. These machines have the numbers 1, 2, 3. . . Etc. are assigned. This order is usually looped or closed so that machines 2 and 3 are hierarchically adjacent and machines “n” and 1 are similar. There is preferably another machine X that is provided to perform various housekeeping functions to operate as a lock server. In particular, another machine X is a low-value machine and can be much cheaper than other machines that can have desired attributes such as processor speed. In addition, an additional low value machine (X + 1) is preferably available to provide redundancy in case machine X fails. If two such server machines X and X + 1 are provided, they preferably operate as dual machines in a cluster configuration for simplicity. Machines X and X + 1 can operate as a multi-computer system according to the present invention, if desired. However, this generally results in undesirable complexity. If machine X is not provided, machine X functions such as housekeeping functions are provided by one, some, or all of the other machines.

  Referring now to FIG. 3, this figure shows a memory map for any three machines, Mn−1, Mn, and Mn + 1, of the plurality of machines that make up the computer system. The initialization process described in the above patent specification incorporated herein takes place prior to the start of operation of the application program, and therefore the memory content of each of the machines is essentially the same. In the particular embodiment shown, each machine has two objects A and B, and each object has two primitive fields 11 that can store alphanumeric data. In the particular example given, the two fields of object A contain the numbers 7 and 9, and the two fields of object B contain the numbers 3 and 5.

  After being initialized as described above, each individual computer executes a different part of the application program 5. It is expected that each machine will only generate revision data that will be stored in both primitive and non-primitive fields. If such fields are primitive fields that contain only alphanumeric data, these fields can be easily copied and thereby replicated on each of the other machines. However, as shown in FIG. 4, i.e., the machine Mn is different from the primitive field 11, so a situation may occur having a reference field 10 indicated by a double border.

  Inside the object A of the machine Mn, there are fields 10, 11, and 12, which correspond to the corresponding fields 30, 31, and 32 in the object A of the machine Mn-1 and in the object A of the machine Mn + 1. Corresponding fields 20, 21, and 22.

  In this particular embodiment, the new reference field 10 contains a reference to an additional object H that itself contains two primitive fields 11. In FIG. 4, the reference field 10 includes both the name H of the referenced object and an arrow indicating that the content of the reference field 10 redirects the program to move from the object A to the object H. It is shown. Thus, problems arise with respect to how the memory changes that occurred on the machine Mn are replicated to all other machines so that the computer system can maintain a substantially consistent memory.

  As shown in FIG. 4, in relation to the machine Mn-1, the object A can have a reference field 30, but the object H to which the reference field 10 of the machine Mn refers exists in the machine Mn-1. This is not enough. Alternatively, as shown for machine Mn + 1, it is possible to have a reference field 20 in object A and create a new object in the machine, but the machine organization is generally different and thus created in machine Mn + 1. The pointer (or address) of the new object is not the same as the pointer (or address) of the object H created in the machine Mn.

  The desired end result is shown in FIG. Here, the machine Mn having the reference field 10 and the additional object H is the same as before. However, for machine Mn + 1, object A has a reference field 20 whose contents are created in the local memory of machine Mn + 1 and refer to a new object T corresponding to object H of machine N. Similarly, the machine Mn-1 has a reference field 30 corresponding to the field 10 for the object A, and the contents of the field are created in the local memory of the machine Mn-1 and the object H of the machine Mn. A new object K corresponding to is referred to.

  The desired result shown in FIG. 5 is created using a concordance table as shown in FIG. Such a concordance table is preferably stored in the server machine X and is therefore accessible to all other machines. In the concordance table of FIG. 6, it can be assumed that the referenced object H (for the purposes of this example, conveniently relates to the aspect of the application program 50 relating to the human head, the global name C (conveniently It is understood that the local pointer (or address) of H is generally different from the global name C by the creation of (represented cranium meaning head in Latin).

  For each of the other machines in the multicomputer system, a local pointer (or address) for the new object needs to be created and then entered into the concordance table of FIG. For machine Mn-1, the local address of the new object is conveniently called K (for Kopf, which means head in German), and for machine Mn + 1, the local address is T (for French, meaning head). It is convenient to represent tete).

  Since objects H, T, and K are all linked through the concordance table of FIG. 6, the contents of the individual primitive fields in object H should be easily copied across the corresponding primitive fields in objects K and T, respectively. Can do.

  Referring now to FIG. 7, it is shown that they exist slightly differently. Here, the processing of the application program 50 performed by the machine Mn generates a new reference field 46 in the object B that refers to the existing object H. It is therefore necessary to make a local copy of the reference field 46 in the corresponding object B contained within the machines Mn-1 and Mn + 1.

  The final result is as shown in FIG. 8, where new reference fields 56 and 66 are created in machines Mn-1 and Mn + 1, respectively. In addition, the content of each of these new reference fields is a reference to objects K and T, respectively corresponding to object H of machine Mn. This creation is possible by examining the concordance table of FIG. 6 so that, for example, machine Mn + 1 recognizes that the object in its local memory corresponding to object H of machine Mn is object T. .

  Referring now to FIG. 9, during the initial loading process, the program 50 loaded to create each JAVA virtual machine 72 is modified. This modification begins at step 90 of FIG. 9 and initially detects all memory locations (called fields in JAVA®, but equivalent terms are used in other languages) in the loaded application 50. Includes entity step 91. Such memory locations need to be identified for further processing in steps 92 and 93. The DRT 71 during the load process creates a list of all memory locations, i.e. identified, and the JAVA field is listed by object and class. Both volatile and sync fields are listed.

  The next stage of the modification procedure (indicated by step 92 in FIG. 9) is to search the executable application code to locate any processing activity, which corresponds to the list generated in step 91. Manipulate or change the field value to be written, so that the value of the corresponding memory location is changed. When such an operation that changes a field value (usually put static or put field in JAVA® language) is detected, at step 93 an "update propagation routine" is Inserted in place to ensure that all other machines are notified that the field contents have changed. Thereafter, the loading process continues in the normal manner as described in the above specification incorporated herein and indicated at step 94 in FIG.

  Another form of initial correction during loading is shown in FIG. Here, the start step 90, listing step 91, and searching step 92 are the same as in FIG. However, instead of inserting an “update propagation routine” in which the processing thread executes the update as step 93, an “alarm routine” is inserted into step 103. The “alert routine” instructs one or more threads that are not used for processing and assigned to the DRT to perform the necessary propagation. This step 103 is a quicker alternative than step 93 of FIG. 9 and results in lower overhead.

  When this initial modification during the loading process as described in FIG. 9 or 10 is performed, one of the multithread processing operations shown in FIGS. 11 and 12 is performed. As can be seen in the embodiment of FIG. 11, threads 111/1. . . A multi-thread process 110 on the machine M1 consisting of 111/4 is performed, and in the process of the second thread 111/2 (in this embodiment), the thread 111/2 recognizes the change of the field value in step 113. It will be. At this stage, normal processing of the thread 111/2 is stopped at step 114, and the same thread 111/2 exchanges the changed field and changed content identity executed at step 113 via the network 53. All machines M2. . . Notify Mn. At the end of this communication procedure, at step 115, thread 111/2 resumes processing until the next instance with field content changes.

  In the other configuration shown in FIG. 12, when the thread 111/2 on the machine M1 recognizes the change of the field value in step 113, the thread 111/2 is changed to another thread 121 assigned to the DRT process 120. / 1 changes the identity of the change field and change content detected in step 113 via the network 53 according to step 128 to all other machines M2. . . Directs DRT process 120 (as indicated by step 125 and arrow 127) to propagate to Mn. This is an operation that can be performed quickly, ie, the processing of the initial thread 111/2 is only momentarily interrupted as shown in step 125 before thread 111/2 resumes processing in step 115. It is. The other thread 121/1 notified of the change (as indicated by arrow 127) then communicates the change to another machine M2. . . Transmit to each of Mn.

  This second configuration of FIG. 12 includes various threads 111/1. . . Take advantage of the processing power of 111/3 and 121/1 (which are generally not affected by equal demands) and provide good expansion with increasing size of “n” (where n is an integer greater than or equal to 2) The total number of machines connected to the network 53 and simultaneously executing the application program 50). Regardless of which configuration is used, the change fields and identities and values detected in step 113 are not changed by other machines M2. . . Propagated to all Mn.

  This is illustrated in FIG. 13 where DRT 71/1 and thread 121/1 in FIG. 12 (represented by step 128 in FIG. 13) are processed at step 113 in FIG. The identity and change contents of the memory location created and listed are transferred to other machines M2. . . Send to each of Mn.

  Other machines M2. . . Each Mn receives the identity and content pair from the network 53 and performs the operations illustrated by steps 135, 136, and 137 in FIG. 13 for the machine Mn by writing the new content to the corresponding local memory location.

  It will be apparent to those skilled in the computer art that the concordance table of FIG. 6 may not be located only within the server machine X. Instead, a local copy of the table can be maintained on each of the individual machines Mn-1, Mn, Mn + 1, etc. In addition, under these circumstances, a global name must exist because each machine can determine the object in local memory that corresponds to the object referenced by any other machine by examining its own table. There is no. For example, if machine Mn receives a message from machine Mn + 1 to update the contents of primitive field 11 contained on object T, machine Mn looks at the concordance table of FIG. It corresponds to the object T, so it is determined that this is the object to be updated. That is, the concordance table of FIG. 6 does not have to include the left column titled “GLOBAL”. For this reason, the table shown in FIG. 6 has a left portion separated by a dashed line to indicate that it is not necessary if server machine X is not present.

  The foregoing describes only some embodiments of the present invention and it will be apparent to those skilled in the computer art that modifications may be made without departing from the scope of the present invention.

  For example, in the configuration described above, “n” computers that each share a part (1 / nth) of the application program are assumed. Under such circumstances, all “n” computers have the same local memory structure. However, a system can be operated in which only a subset of computers have the same local memory structure. In this case, the maximum number of members in the subset will be considered “n” in the above description.

  It should also be understood that a memory location can include both data and a portion of code. Thus, changes made to new values or memory locations can include both new numerical data and new or revised portions of code. Similarly, references to JAVA include both the JAVA language and the JAVA platform and architecture.

  In all described cases of modification, if the application code 50 is modified before loading, during loading, or after execution of unmodified application code begins after loading, the improved application code is It should be understood that subsequent to the modification being made, it is loaded in place of the unmodified application code and executed in place of the unmodified application code.

  Alternatively, in cases where the modification is done after loading and after execution of the unmodified application code begins, the unmodified application code is totally replaced with the modified application code as the modification is performed. It should be understood that it can be replaced or partially or incrementally replaced when incremental modifications are made to the unmodified application code being executed. Regardless of which such modification route is used, subsequent modifications are performed instead of unmodified application code.

  A plurality of machines M1, M2. . . Use global identifiers in the form of “meta-name” or “meta-identity” for all similar equivalent local objects (or classes, or assets or resources or the like) on each machine of Mn Is advantageous. For example, instead of tracking each unique local name or identity of each similar equivalent local object on each machine of multiple similar equivalent objects, each machine associates a global name with a particular local name or object. Under the conditions (for example, “global name 7787” corresponds to the object “local object 456” on the machine M1, “global name 7787” corresponds to the object “local object 885” on the machine M2, and “global name 7787” ”Corresponds to the object“ local object 111 ”on the machine M3, etc.) and defines or uses a global name (eg“ global name 7787 ”) corresponding to a plurality of similar equivalent objects on each machine. Can.

  In the table or list or other data structure created by each DRT 71 when initially recording or creating a list of all or some subsets of all objects (eg memory locations or fields), each machine M1, M2,. . . For each such recorded object on Mn, the machines M1, M2. . . It will be apparent to those skilled in the art in view of the detailed description provided herein that there is a common or similar name or identity on each of Mn. However, in an individual machine, each machine can store and generally store memory values or content in different memory locations according to its own internal process, so a given name or identity The local object corresponding to will change or may change over time. Thus, a table, or list, or other data structure in each of the DRTs will generally have a different local memory location corresponding to a single memory name or identity, but each global “memory name” or identity is Will have the same “memory value or content” stored in different local memory locations. Thus, for each global name, there will be a family of corresponding independent local memory locations with one family member in each of the computers. Although local memory names may be different, assets, objects, locations, etc. have essentially the same content or values. Thus, the family is consistent.

  The term “table” or “tabulation” as used herein is intended to include a list or organized data structure in any format that can store and read data in sequence.

It will be apparent to those skilled in the art in view of the description provided herein that the above modifications of the application program code 50 being loaded can be accomplished in many ways or by various means. These methods or means include, but are not limited to, at least the following five methods and variations or combinations of these five methods.
(I) Recompilation at load (ii) Pre-load processing by pre-compilation (iii) Compile before load (iv) “Just-in-time (JIT)” compilation (v) Recompilation after load (however, Or, for example, prior to execution of relevant or corresponding application code in a distributed environment).

  Conventionally, the term “compile” means, for example, the conversion of code or language from source to object code or from one language to another. Specifically, the use of the term “compile” (and its grammatical equivalents) herein is not so limited and can include or encompass modifications within the same code or language.

  A plurality of machines M1, M2. . Perform or implement this coordinated consistent memory state and manipulation operation concepts, methods, and procedures given the basic concept of modifying memory manipulation operations to coordinate operations between Mn There are several different methods or embodiments that can be used.

  In the first embodiment, a particular machine, eg, machine M2, loads and modifies an asset (such as a class or object) that includes a memory manipulation operation, and then other machines M1, M3. . . Load a modified object (or class or other asset or resource) containing a new modified memory manipulation operation into each Mn (sequentially or simultaneously, or according to any other order, routine, or procedure). There can be one or more memory manipulation operations corresponding to only one object in the application code, or there can be multiple memory manipulation operations corresponding to multiple objects in the application code. Please note that. Note that in one embodiment, the loaded memory manipulation operation is executable intermediate code.

  In this configuration, which can be referred to as “master / slave”, slave (or secondary) machines M1, M3. . . Each of Mn loads a modified object (or class), through a computer communication network or other communication link or path by a master (or primary) machine, such as machine M2, or some other machine as machine X Contains newly modified memory manipulation operations sent. In a slight variation of this “master / slave” or “primary / secondary” configuration, the computer communication network can be replaced by a shared storage device such as a shared file system or a shared document / file repository such as a shared database. .

  It will be apparent from the detailed description presented herein that the modifications performed on each machine or computer are not necessary and often not the same or identical. What is needed is a similar complete method modification in which each of the machines operates to be consistent and consistent with the other machines. Further, it will be appreciated that there are a variety of ways to implement modifications that may vary depending on, for example, specific hardware, architecture, operating system, application program code, or the like, or different elements. Let ’s go. Inside the operating system, outside any operating system, or without the benefit of the operating system, inside the virtual machine, in EPROM, in software, in hardware, in firmware, or any of these It will be understood that a combination of these can be implemented.

  In still further embodiments, each machine M1, M2,. . . Mn receives an unmodified asset (such as a class or object) that contains one or more memory manipulation operations, but modifies the operation and then loads an asset (such as a class or object) that consists of the currently modified operation To do. One machine, such as a master or primary machine, can customize or perform different modifications to the memory manipulation operations sent to each machine, and in this embodiment, the modifications made by each machine are slightly different. To make it easy to do. This allows for expansion, customization, and / or optimization based on that particular machine architecture, hardware processor, memory, configuration, operating system, or other elements, but still other machines and others Can still be similar, consistent and consistent for all similar modifications.

  In all of the described cases or embodiments, the machines M1, M2. . . Providing or communicating asset codes (such as class codes or object codes) to machines including Mn and optionally machine X provides direct communication between machines (eg, M2 directly, M1, M3, M4, etc. Or provide or use cascade or sequential communication (eg, M2 provides to M1, then M1 provides to M3, then M3 provides to M4, and so on) Can be branched, distributed, or communicated between different machines in any combination or permutation, such as by direct or cascade and / or sequential combinations.

  The above-described configuration is a clean-up routine, finalization, or the like where the modification will be performed only by one of the computers in this "master / slave" or "primary / secondary" configuration variant In the case of things need to change, machine M2 loads an asset (such as a class or object) that contains an unmodified form of cleanup routine on machine M2, and then (for example, M2 or each local machine ) Remove any unmodified cleanup routines that existed in whole or in part on the machine (such as classes or objects) and make use of the computer communication network to modify the current machine on other machines or Modified for assets with deleted cleanup routines To load the over de. Thus, in this case, the modification is not the conversion, equipment, translation, or compilation of the asset cleanup routine, but the deletion of the cleanup routine on all machines except one. In one embodiment, the actual code-block of the finalizing or cleanup routine is deleted on all but one machine, and all other machines are deleting the finalizing routine, so at this end The remaining machine is the only machine that can execute the finalize routine. One advantage of this approach is that since only one machine has a routine, there is no contention between multiple machines executing the same finalization routine.

  The overall clean-up routine deletion process can be performed by a “master” machine (eg, machine M2, or some other machine such as machine X) when an unmodified asset is received, or each other machine M1, M3. . . . Can be performed with Mn. Another variation of this “master / slave” or “primary / secondary” configuration is the machine M1, M2. . . Use a shared storage device such as a shared file system or a shared document / file repository such as a shared database as a means of exchanging code for assets, classes or objects between Mn and optionally server machine X. .

  In a further configuration, a particular machine, eg, machine X1, loads an unmodified asset (such as a class or object) that includes a finalize or cleanup routine, and all other machines M2, M3. . . Mn performs the modification, removes the asset (such as class or object) cleanup routine, and loads the modified version.

  In yet another configuration, the machines M1, M2. . . Mn can send some or all load requests to the additional server machine X, which uses the application program code 50 (assets and / or classes, and (Including / consisting of objects), including finalization or cleanup routines, and returning modified application program code including modified finalization or cleanup routines to each of the machines M1 to Mn, then Machine locally loads the modified application program code including the modification routine. In this configuration, machines M1 through Mn forward all load requests to machine X, which returns the modified application program code, including modified finalization or cleanup routines, to each machine. The modifications performed by machine X can include any of the modifications described. Of course, this configuration can only be applied to a portion of the machine, and other configurations described herein apply to the rest of the machine.

  Those of ordinary skill in the computer and / or programming arts will recognize that if additional code or instructions are inserted into and modify existing code or instructions, the existing code or instruction set will be offset, branch, attribute, It will be appreciated that markups, and the like, may require further modifications (eg, by renumbering sequential instructions, etc.) so that they can be processed or responded correctly.

  Similarly, in the JAVA language, memory locations include both field types and array types, for example. The above description deals with fields, and the required changes to the array type are essentially the same required changes. The present invention also relates to Microsoft. Programming languages (procedural, declaration, and object-oriented languages similar to JAVA) including NET platform and architecture (VisualBasic, Visual C / C ++, and C #), FORTRAN, C / C ++, COBOL, BASIC, etc. Is equally applicable.

  The terms object and class used herein are derived from the JAVA environment and are from different environments such as a dynamic link library (DLL), or an object code package, or a functional unit or memory location. Includes derived similar terms.

  Various means relating to embodiments of the present invention are described including, but not limited to, locking means, distributed runtime means, modifiers or modification means, and the like. In at least one embodiment of the present invention, any one or each of these various means is a computer program code statement or instruction (possibly including a plurality of computer program code statements or instructions). Executing in computer logic, processor, ASIC, logic or electronic circuit hardware, microprocessor, microcontroller, or other logic, and modifying the operation of such logic or circuit, Achieve the operations or functions described. In another embodiment, any one or each of these various means can be implemented in firmware, and in other embodiments they can be implemented in hardware. Furthermore, in at least one embodiment of the present invention, any one or each of these various means may be implemented by a combination of computer program software, firmware, and / or hardware.

  Any and each of the methods, procedures, and / or routines described above are advantageously stored on some tangible medium, or exist in electronic, signal, or digital form. Can be implemented as Such a computer program or computer program product may be a separate, and / or module, program, or subroutine for execution in processing logic in a computer, computer machine, processor or microprocessor of an information appliance, etc. Including instructions organized as or in any other manner; the computer program or computer program product is coupled to the operations performed by the computer, or the computer on which the computer program or computer program product resides or is running, Modify the operation of the computer on the computer that is connected or otherwise in signal communication. Such a computer program or computer program product modifies the operational and architectural structure of a computer, computer machine, and / or information appliance, changes the technical operation of the computer, and provides the technical capabilities described herein. To achieve a positive effect.

  Accordingly, the present invention comprises a method, procedure, routine, comprising a set of program instructions stored in a storage medium or electronically present in any form and included in any of the claims herein. Or a computer program product operable to allow multiple computers to implement any of the same.

  Furthermore, the present invention provides a single computer adapted to interact with multiple computers or with multiple computers interconnected via (but not limited to) a communication network or other communication link or path. Each of which is operable to execute the same or different portions of application code written to run only on a single computer of a corresponding different computer of the computer at substantially the same time or concurrently. The computer is programmed to perform any of the methods, procedures, or routines described herein or as claimed in any of the claims when a computer program product is loaded or upon subsequent instructions. . Similarly, the present invention also includes within its scope a single computer arranged to cooperate with the same or substantially similar computers to form a multi-computer system.

In summary, a non-primitive field of a replicated object is replicated in a multi-computer environment where different portions of at least one application program are executed simultaneously on different computers of a plurality of computers interconnected via a communication network. A method is disclosed, the method comprising:
(I) creating a concordance table and for each object present in any one of the plurality of computers, an entry in the concordance table corresponds to each reference to the object;
(Ii) Each entry in the concordance table contains a local pointer to a local memory object referenced by an object on one machine and duplicates the concordance table on each computer or all existing in the server computer. Allowing each computer to access the corresponding part of a single concordance table for the machine;
(Iii) causing each other machine to designate a corresponding non-primitive field and a local object, and entering a corresponding local pointer of the corresponding local memory object into one or more tables.
Preferably,
(Iv) further comprising using the global name in a table corresponding to the corresponding non-primitive field or all local pointers of the corresponding object;
Preferably,
(V) if processing for one of the application program parts requires creation of a second or next reference non-primitive field in one of the machines, the corresponding second or next reference non-primitive The method further includes creating a primitive field on each of the other machines of the machine.
Preferably,
(Vi) a further step of executing different portions of the application program utilizing one of the multithreads in each computer;
(Vii) A thread requesting creation of a second or next reference non-primitive field creates a corresponding second or next reference non-primitive field for each of the other computers of the computer. Instructing
Is further included.
Preferably,
(Viii) executing different portions of the application program using one of the multithreads in each computer;
(Ix) a thread that is different from the thread requesting creation of the second or next reference non-primitive field for each other computer of the computer corresponding to the second or next reference non-primitive Instructing them to create a field,
Is further included.

  Further disclosed is a multi-computer system in which different portions of at least one application program are simultaneously executed on different computers of a plurality of computers interconnected via a communication network, and created on any one of the computers For each non-primitive field, there is a corresponding entry in the concordance table that is accessible by all computers or replicated at each computer, and the table entry is to the local memory object referenced by the non-primitive field of one computer. Including local pointers, the computer specifies each other a corresponding non-primitive field and a local object, and a corresponding pair of local memory objects. Local pointer is input to one or more of concordance tables.

  Preferably, one or more tables utilize a global name corresponding to a corresponding non-primitive field or all local pointers of a corresponding object.

  Preferably, for each second or subsequent reference non-primitive field in one of the computers, a corresponding second or subsequent reference non-primitive field is created in each of the other computers of the computer. .

  Preferably, each computer utilizes multi-thread processing to execute different parts of the application program, and a thread requesting the creation of a second or subsequent reference non-primitive field is sent to each of the other computers of the computer. Instructs the second or next reference non-primitive field to be created.

  Alternatively, each computer uses multi-thread processing to execute a different part of the application program, and a thread different from the thread requesting the creation of the second or subsequent reference non-primitive field is Instruct each of the computers to create a second or subsequent reference non-primitive field.

  A plurality of computers are provided that are interconnected via a communication network and operable to reliably perform any of the methods described above.

  There is further provided a computer program product comprising a set of program instructions stored in a storage medium and operable to cause a plurality of computers to perform any of the methods described above.

  A single computer is disclosed that is adapted to cooperate with at least one other computer to perform any of the methods described above or to form a computer system as described above.

  As used herein, the term “comprising” (and grammatical variations thereof) is used in a comprehensive sense such as “having” or “including” and not in an exclusive sense of “consisting solely of”.

1 is a schematic diagram of a prior art computer arranged to operate JAVA code and thereby constitute a single JAVA virtual machine. FIG. FIG. 1B is similar to FIG. 1A but shows the initial loading of code. FIG. 2 is a diagram showing interconnection of a plurality of computers, each of which is a JAVA (registered trademark) virtual machine for forming a multicomputer system. FIG. 4 is a diagram showing “n” application execution computers to which at least one additional server machine X is connected as a server. FIG. 6 is a schematic map of memory locations in a plurality of machines showing memory locations including objects and fields. FIG. 4 is a memory map similar to FIG. 3 but showing the creation of a reference field that references a new object. Fig. 4 is a memory map showing a successful copy of a newly created reference field. It is a table that lists the corresponding reference fields. It is a memory map which shows creation of another reference field. Fig. 6 is a memory map showing a successful copy of another reference field. Fig. 6 is a flowchart of procedures performed during loading of the same application on each machine in the network. It is a flowchart which shows the improvement procedure similar to FIG. FIG. 9 is a schematic diagram of multi-thread processing performed on the machine of FIG. 8 utilizing the first embodiment of memory update. FIG. 12 shows another embodiment similar to FIG. 11. FIG. 9 illustrates a multi-thread memory update for the computer of FIG.

Claims (13)

A method for duplicating a non-primitive field of a duplicated object in a multi-computer environment where different parts of at least one application program are executed simultaneously on different computers of a plurality of computers interconnected via a communication network. And
(I) creating a concordance table and for each object present in any one of the plurality of computers, an entry in the concordance table corresponds to each reference to the object;
(Ii) Each entry in the concordance table contains a local pointer to a local memory object referenced by the object of the one machine, and each computer replicates the concordance table or server computer Allowing each computer to access corresponding parts of a single concordance table for all machines present in the machine;
(Iii) causing each other machine to specify a corresponding non-primitive field and a local object, and inputting a corresponding local pointer of the corresponding local memory object to the one or more tables;
Including methods. (Iv) further comprising using a global name in the table corresponding to the corresponding non-primitive field or all local pointers of the corresponding object;
The method of claim 1. (V) if processing for one of the application program parts requires the creation of a second or next reference non-primitive field in one of the machines, the corresponding second or next Further comprising creating a reference non-primitive field on each of the other machines of the machine;
The method according to claim 1 or 2. (Vi) executing the different portions of the application program using one of the multi-threads in each computer;
(Vii) a thread requesting creation of the second or next reference non-primitive field to each of the other computers of the computer for the corresponding second or next reference non-primitive field; Instructing them to create
including,
The method according to claim 3. (Viii) executing the different portions of the application program utilizing one of the multi-threads in each computer;
(Ix) a thread different from the thread requesting the creation of the second or next reference non-primitive field is sent to each of the other computers of the computer for the corresponding second or next Instructing to create a reference non-primitive field;
Further including
The method according to claim 3. A multi-computer system in which different parts of at least one application program are executed simultaneously on different computers of a plurality of computers interconnected via a communication network,
For each non-primitive field created on any one of the computers, there is a corresponding entry in the concordance table that is accessible by all computers or replicated on each computer;
The table entry contains a local pointer to a local memory object referenced by a non-primitive field of the one computer;
The computer specifies a corresponding non-primitive field and a local object to each other, and a corresponding local pointer of the corresponding local memory object is input to the one or more concordance tables;
A multi-computer system characterized by that. The one or more tables utilize corresponding global names corresponding to all non-primitive fields or all local pointers of corresponding objects;
The system according to claim 6. For each second or next reference non-primitive field in one of the computers, a corresponding second or next reference non-primitive field is created in each of the other computers of the computer.
The system according to claim 6 or 7, characterized by the above. A thread that executes different parts of the application program using multi-thread processing in each computer and requests creation of the second or next reference non-primitive field is sent to each of the other computers of the computer. Directing the second or next reference non-primitive field to be created,
The system according to claim 8. A thread different from the thread that executes the different parts of the application program using multi-thread processing in each computer and requests the creation of the second or next reference non-primitive field is another computer of the computer Instructing each to create the second or next reference non-primitive field;
The system according to claim 8.   A plurality of computers interconnected via a communication network and operable to reliably perform the method of any one of claims 1-5.   6. A computer program product stored in a storage medium and comprising a set of program instructions operable to allow a plurality of computers to perform the method of any one of claims 1-5.   Cooperating with at least one other computer to perform the method according to any one of claims 1 to 5 or to form the computer system according to any one of claims 6 to 11. A single computer adapted to do.

Images