JP2009512028A - Improved machine architecture with partial memory update - Google Patents

Abstract

A plurality of computers M1, M2,. . . . In a multi-computer environment where at least one application program (50) is simultaneously executed on Mn, only updates of several memory locations are disclosed. Memory locations (A, B, D, E, X) in local memory are categorized into two groups. Each first group of memory locations (X1, X2,... Xn, A1, A2,... An) is accessible by other computers. Each second group of memory locations (B, E) is only accessible by a computer having a local memory containing the memory location. Only changes to the value of the memory location in the first group are sent to all other computers. If the application program execution means that the memory location in the second group is referenced by the memory location in the first group (ie, the first group location refers to the second group location), the memory location in the second group A promotion mechanism for promotion to the first group is disclosed.
[Selection] Figure 24

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.

  In many cases, the above arrangement works satisfactorily. This is especially true when the programmer recognizes that there may be an update delay and can adjust the program flow to resolve it. However, there may be a problem with using old content or values instead of the latest content.

  The basis of the present invention is the desire to increase the operating speed of multicomputer systems by reducing the volume of data that needs to be updated.

According to a first aspect of the present invention, different portions of at least one application program described to be executed only on a single computer are each executed substantially simultaneously on corresponding different computers of the plurality of computers. A method is disclosed for selecting independent memory locations that are updated at approximately the same time in a multi-computer environment, the method comprising:
(I) selecting a first group of memory locations that are each replicated to each computer;
(Ii) ignoring the second group of memory locations, each existing only in a particular computer of the computers where each memory location is physically located;
(Iii) promoting any memory location from which the memory location in the first group starts to reference from the second group;
(Iv) replicating the promoted second group location to all other computers other than computers physically located when in the second group;
(V) assigning a duplicated and promoted second group location to the first group;
(Vi) updating the first group locations of other computers of the computer substantially simultaneously with any changes made to the first group location of any one of the computers;
including.

  According to a second aspect of the present invention, different portions of at least one application program described to be executed only on a single computer are each executed substantially simultaneously on corresponding computers of the plurality of computers. A multi-computer system is disclosed wherein each of a plurality of computers has an independent local memory, all of the plurality of computers are interconnected by a communication network, and the memory locations present in the local memory are in two groups A first group of memory locations that are each replicated on each computer, and a second group of memory locations that each exists only within a particular computer of the computers in which each second group memory location is physically present Categorized in The system comprises: a memory updating means for updating any changes made to a first group of memory locations in one computer over all other corresponding memory locations in another computer via a communication network; And elevating means for promoting any memory location of the second group currently referenced at the top by the first group of memory locations from the second group to the first group as a result of execution of the application program.

  According to a third aspect of the invention, there is disclosed a single computer adapted to cooperate with at least one other computer to perform the above method or to form the above computer system. Is done.

  According to a fourth aspect of the invention, there is provided 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 method defined above. Disclosed.

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

  Next, preferred embodiments of the present invention will be described with reference to the drawings.

  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.

  The present specification, which is incorporated by reference above, discloses a system that can update the corresponding memory location to ensure that the contents of each local memory, apart from the transmission delay, are substantially the same. ing. However, as the number of machines increases and the complexity of application programs increases, the volume of data that needs to be transmitted over the communication network 53 also increases.

  In order to overcome this problem, according to one embodiment of the present invention, memory locations that potentially require updating are divided into at least two categories. The first category consists of memory locations accessible by any two or more of the plurality of machines and therefore should be updated continuously. The second category consists of memory locations that are accessible only by the local machine where the memory location is physically located. At these memory locations, the content of that memory location is first replicated to all other machines, and then the content of the replicated memory location continues to be updated each time the original local memory content changes. That is not desirable. Memory locations that fall into two categories can be easily distinguished by the presence of pointers to the relevant memory locations. There are several mechanisms or modes that allow this categorization and data transfer.

  Referring now to FIG. 3, a plurality of machines M1, M2,. . . . . Each of Mn (other than any server machine X, if present) has a memory location indicated schematically. In the machine M1, a class X1 and an object B exist. In the machine M2, the same class X2 and the object D as the machine M1 exist. In the machine Mn, the same class Xn and two objects A and E exist. The contents of memory location X are the same for each machine, and each machine can both read from and write to memory location X. For this reason, the boundary of the memory location X is indicated by a double line.

  Preferably, maintaining a table that lists each memory location and the machines that can access each memory location in the table is convenient for server machine X of FIG. Such a table is called a reachability table and is shown in FIG. The first row of the table of FIG. 4 deals with memory location A that can only be accessed by machine Mn. The second row of the table of FIG. 4 deals with memory location B that can only be accessed by machine M1. Similarly, object D can only be accessed by machine M2, and object E can only be accessed by machine Mn. However, class X can be accessed by all of the machines M1, M2 and Mn.

  In the multi-machine environment described above, if a Class X content is changed by being written by one of the machines, the content change needs to be transmitted to all other machines via the network 53. However, since objects A, B, D, and E can each be accessed only by a single machine and only by its local machine, either in creating or updating the contents of these memory locations. It doesn't make much sense.

  Class Xn is said to refer to object A if class Xn needs to refer to object A while being processed by a particular machine, eg, machine Mn. This is illustrated in FIG. 5 by the arrow pointing from class Xn to object A. A change in the status of object A means that it can be accessed or referenced by all other machines. For this reason, it is named object An in FIG. 5 and is surrounded by a double line and is reproduced on each of the other machines as objects A1, A2, etc. Further, the arrows indicate the corresponding reference objects A1, A2, etc. from the corresponding classes X1, X2, etc. As a result of this change in the status of object A, the first row of the reachability table of FIG. 4 has been modified to indicate that object A can be reached by machines M1, M2, and Mn, as shown in FIG. Is done. The server machine X of FIG. 2 uses the modified reachability table of FIG. 6 to ensure that when the contents of object A are modified by one machine, all other machines are sent over the network 3. To be.

  Figures 7 and 8 show another modification. Here, the object A in the machine Mn points to a new object K as a result of the process executed by the machine Mn. As a result, it becomes necessary to insert additional rows into the reachability table as shown in FIG. This new row indicates that object K can only be accessed by machine Mn.

  In such a case, the situation shown in FIG. 9 occurs when the correction described above with respect to FIG. 5 is made. Since class Xn here refers to object An, object A is replicated to each of the other machines as before. However, since the object An itself points to the object K, each of the objects K needs to be duplicated on each of the other machines. Thereby, the objects K1, K2,. . . . . Kn is generated. In addition, each of these objects is accessible by the entire machine, so that these objects are indicated by double lines in FIG. The corresponding change to the reachability table is shown in FIG. 10, where object K is shown to be accessible by all machines.

  The detailed description above refers to memory locations, but is equally applicable to structures, assets, or resources (referred to as classes or objects in JAVA). These are already assigned names or tags that can be used globally by all machines (as it is understood that the local memory structures of different machines may be different). Thus, a local or actual name assigned to a particular memory location on one machine can be completely different from a local name assigned to a corresponding memory location on another machine. This global name assignment preferably occurs during the load-time compilation process when the class or object is first initialized. This is most conveniently done via a table maintained by server machine X. This table can also include reachability data.

  It will be apparent to those skilled in the computer arts that reachability data allows a structure, asset, or resource (ie, memory location) to be divided into two categories or classes. The first category consists of these locations that can be accessed by all machines. Write operations performed on such memory locations need to be distributed across all machines so that all corresponding memory locations have the same content (except for delays due to the transmission of update data). However, for the second category, since these memory locations are only accessible by the local machine, write operations to these memory locations do not need to be distributed to all other machines and are supported on other machines. There is also no need for a memory location. As a result of this categorization, it is not necessary to send a significant amount of data from one machine to another, thus significantly reducing the amount of traffic on network 53.

  In the foregoing description, a single reachability table is provided that is located in and maintained by server machine X. However, if it is desirable for each machine to manipulate its own reachability table, the computer system can be operated without the server machine X. FIGS. 11-14 show individual reachability tables for individual machines under conditions corresponding to FIGS. 4, 6, 8, and 10, respectively.

  That is, in FIG. 11, the table for machine M1 has a row for class X and a row for object B. Similarly, the table for machine M2 has a row for class X and a row for object D. However, the table for machine Mn has three rows, one for class X and one for each of objects A and E. When the changes shown by the comparison of FIGS. 3 and 5 occur, class Xn refers to object An, so all other classes X1, X2, etc. must refer to the corresponding objects A1, A2, etc. All machines must contain one row in the machine reachability table for object A. This is the situation shown in FIG. Other machines are said to inherit table entries for object A.

  Machine Mn can determine that object A needs a duplicate of the entire other machine by examining the table entry for class X on machine Mn. In the situation shown, machine Mn makes an affirmative decision about replication by comparing table entries for object A and class X. If the table entry for object A contains all machines in the table entry for class X, then machine Mn correctly determines that object A does not need to be duplicated for any other machine. Can do. Furthermore, it is not necessary to add or update table entries to other machines. Alternatively, if the table entry for object A does not include the full set of machines in the table entry for class X, machine Mn updates the table entry for object A and is listed in the table entry for class X. A set of machines, and for all machines listed in the new table entry for object A, for the object A in the set of machines listed in the new table entry for object A on machine Mn. Instructs the local table to be updated. Finally, for a set of machines that did not already exist in the table entry for object A on machine Mn prior to the inheritance of the set of class X machines on machine Mn, machine Mn will be able to identify these machines (ie, , Instruct machines M1 and M2) to add a local table entry for object A and create a local replica in memory for a reference to object A and the associated class X.

  Similarly, with respect to FIG. 7, when additional objects K are created by machine Mn, machines M1 and M2 do not have local replicas of object K, and these are for objects A and K, as shown in FIG. Since there is no table entry, an additional row for object K is created in the reachability table for machine Mn, as shown in FIG. As shown in FIG. 9, the assignment of the reference of the object A to the class X requires that the object A inherits the table entry of the class X. However, in addition to this, when object A references object K, object K also inherits the object A's newly updated table entry (including the inherited value of the table entry for class X). , Class X table entries must be inherited indirectly. In accordance with the update of the table entry for objects A and K on machine Mn, machine Mn instructs all machines listed in the table entries for objects A and K to update their local tables, and Instructs all machines not originally present in the A and K table entries to create local copies of objects A and K, respectively. The resulting table for an individual machine is shown in FIG.

  A further embodiment is shown in FIG. Here, the objects indicating A1 and A2 are shared on the machines M1 and M2, but do not exist on the machine Mn. This is shown in the table entry for object A in FIGS. 16 and 17, which shows a single reachability table used by server machine X or multiple reachability tables used by individual machines, respectively. As shown in FIG. 18, the machine M2 that is processing the application program assigns the reference of the object D to the object A. As a result, DRT 71/2 examines table entries for objects D and A on machine M2. This interrogation of the table determines that the table entry for object D does not include all machines in the set of machines listed in the table entry for object A. Thus, the table entry for object D on machine M2 is updated to include the machine for the table entry for object A that does not already exist in the table entry for object D, which in this case is an additional machine M1. According to this operation, the machine M2 creates a table entry for the object D consisting of the machines listed in the currently updated table entry for the object D on the machine M2 for the machine M1, and makes a local copy of the object D. Instruct to create. The resulting changes to the single reachability table and the multiple reachability table are shown in FIGS. 19 and 20, respectively.

  Another embodiment in which the addition of a reference to object A assigned to class X is performed by machine M1 is shown in FIG. As a result, the table for class X and object A is examined to determine whether object A changes its reachability state. If the table entry for object A includes all machines in the table entry for class X, no additional action is performed. However, similarly to the case of FIG. 21, when the class X includes a machine that is not included in the table entry for the object A in the table entry, the reachability change is performed. In accordance with this change, machine M1 updates the entry for class X. In addition, machine M1 instructs all other machines to add and / or update a table entry for object A to be the same as the currently updated table entry for object A on machine M1. According to this operation, any machine that does not yet exist in the table entry for object A is instructed to add that table entry for object A and create a duplicate in object A's local memory (in this case). Required only on machine Mn). However, machine M1 also recognizes that object A refers to object D, and therefore object D must inherit the reachability change of object A. As a result, the table entry for object D is updated to include all machines listed in the updated table entry for object A.

  In addition to the above, machine M1 is also updated on machine M1 with a table entry for object D for all machines that were not previously included in the table entry for object D (in this case only machine Mn). A value equal to the table entry value is added to instruct to create a duplicate in the local memory of object D. Further, the machine M1 instructs all other machines (in this case, only the machine M2) to update the table entry for the object D with the new table entry value updated on the machine M1. A single reachability table and a multiple reachability table reflecting these changes are shown in FIGS. 22 and 23, respectively.

  Referring now to FIG. 24, the position shown in FIG. 18 is modified by the class X of the machine M1 that is assigned a reference to the object D. In connection with this event, the reachability table for object D and class X is examined by DRT 71/1 for the possibility of a change in reachability. As a result, table entries for object D and class X are compared, and if the table entry for object D includes all machines listed in the table entry for class X, no additional action is required. Alternatively, if the table entry for object D does not include all the machines listed in the table entry for class X, the reachability change is made and the resulting action is required.

  As shown in FIG. 24, the machine M1 determines that the object D has undergone reachability change. As a result, machine M1 first updates the table entry for object D to include all machines in the table entry for class X. For each new machine that was not previously in the set of table entries for object D, machine M1 will, for each such machine, object D equal to the currently updated machine entry for object D on machine M1. Add a local table entry for and instruct to create a replica in the local memory of object D. For each other machine, machine M1 also instructs the other machine to update its table entry for object D to be equal to the table entry for object D in machine M1. A single reachability table and a multiple reachability table reflecting these changes are shown in FIGS. 25 and 26, respectively.

  The foregoing describes only some embodiments of the present invention, and it will be apparent to those skilled in the art that modifications may be made without departing from the scope of the invention. For example, the tables of FIGS. 4, 6, 8, and 10 all show a row corresponding to each memory location. In practice, for memory locations such as D and E that are only accessible by the local machine, there is no need to have a row in the table. Instead, such a row is created only when the memory location becomes accessible by one or more other machines. 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.

  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, different portions of at least one application program written to run only on a single computer are updated almost simultaneously in a multi-computer environment where each of the plurality of computers is executed almost simultaneously on different corresponding computers. A method for selecting independent memory locations is provided, the method comprising:
(I) selecting a first group of memory locations that are each replicated to each computer;
(Ii) ignoring a second group of memory locations, each existing only in a particular computer of the computers where each memory location is physically located;
(Iii) promoting any memory location from which the memory location in the first group starts to reference from the second group;
(Iv) replicating the promoted second group location to all other computers other than the computer physically located at k as being in the second group;
(V) assigning a duplicated and promoted second group location to the first group;
(Vi) updating the first group location of another computer of the computer substantially simultaneously with any changes made to the first group location of any one of the computers;
including.
Preferably, the method comprises
(Vii) Promoting any one or more memory locations referenced by the promoted second group memory location itself from the second group of memory locations, whereby the memory location referenced by the promoted memory location is , Including the additional step of inheriting the promotion of the referenced memory location.
Preferably, the method comprises
(Viii) including an additional step of maintaining a table listing the first group of memory locations.
Preferably, the method comprises
(Ix) including the further step of maintaining one table for all the plurality of computers on another server computer.
Alternatively, this method
(X) including an additional step of maintaining one of the plurality of tables on each of the plurality of computers.

  Preferably, the memory location includes an asset, structure, or resource. A multi-computer system in which different portions of at least one application program described to be executed only on a single computer are each executed substantially simultaneously on different corresponding computers of the plurality of computers, Each having an independent local memory, all of the plurality of computers are interconnected by a communication network, and the memory locations present in the local memory are duplicated on each computer in two groups: A first group of memory locations, and a second group of memory locations, each of which exists only within a particular computer of the computers in which each second group memory location is physically present, Two Memory update means for updating any changes made to the first group of memory locations in the computer over all other corresponding memory locations of other computers via the communication network; and as a result of execution of the application program And a means for promoting any of the memory locations of the second group currently referenced at the top by the memory locations of the first group from the second group to the first group.

  Preferably, the promotion means includes inheritance means operable to promote any one or more memory locations referenced by the promoted second group memory location itself from the second group of memory locations. Preferably, the promotion means includes a table that lists the first group of memory locations.

Preferably, the system has one table for all of the plurality of application program execution computers existing in another server computer.
Alternatively, this system has a plurality of tables in each of a plurality of application program execution computers.
Preferably, the memory location includes an asset, structure, or resource.
In addition, a computer program product is provided that includes a set of program instructions stored in a storage medium and operable to allow a plurality of computers to perform any of the methods described above.
Similarly, a plurality of computers are provided that are interconnected via a communication network and that are operable to reliably perform any of the methods described above.

  In addition, a single computer is provided that is adapted to cooperate with at least one other computer to perform any of the methods described above or to form the computer system 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 illustrates an initial load of code similar to FIG. 1A. 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. 2 is a schematic diagram of “n” application execution computers to which at least one additional server machine X is connected as a server. FIG. 5 is a schematic map of memory locations in all of a plurality of machines showing memory locations including classes and objects. 4 is a table showing the various memory locations of FIG. 3 and the capabilities reached. FIG. 4 is a map similar to FIG. 3 showing the result of memory location X pointing to memory location A. FIG. It is an arrival possibility table corresponding to FIG. FIG. 4 is a map similar to FIG. 3 showing a memory location A pointing to a new memory location K. FIG. It is an arrival possibility table corresponding to FIG. FIG. 8 is a map similar to FIG. 7 showing the result of memory location X pointing to memory location A. FIG. 10 is an arrival possibility table corresponding to FIG. 9. It is a figure which shows the multiple arrival possibility table corresponding to the arrival possibility table of FIG. It is a figure which shows the multiple arrival possibility table corresponding to the arrival possibility table of FIG. It is a figure which shows the multiple arrival possibility table corresponding to the arrival possibility table of FIG. It is a figure which shows the multiple arrival possibility table corresponding to the arrival possibility table of FIG. FIG. 6 is a diagram illustrating additional memory changes. It is a figure which shows the single arrival possibility table corresponding to the memory change of FIG. It is a figure which shows the multiple arrival possibility table corresponding to the memory change of FIG. It is a figure which shows another memory change. It is a figure which shows the single arrival possibility table corresponding to the memory change of FIG. It is a figure which shows the multiple arrival possibility table corresponding to the memory change of FIG. It is a figure which shows another memory change. It is a figure which shows the single arrival possibility table corresponding to the memory change of FIG. It is a figure which shows the multiple arrival possibility table corresponding to the memory change of FIG. It is a figure which shows another memory change. It is a figure which shows the single arrival possibility table corresponding to the memory change of FIG. It is a figure which shows the multiple arrival possibility table corresponding to the memory change of FIG.

Explanation of symbols

53 Network M1 M2 Mn Machine A1 A2 Object B Object D1 D2 Dn Object E Object X1 X2 Xn Class

Claims (15)

Different portions of at least one application program that are described to run only on a single computer are updated substantially simultaneously in a multi-computer environment, each running almost simultaneously on a corresponding different computer of the plurality of computers. In order to select independent memory locations,
(I) selecting a first group of memory locations that are each replicated on each computer;
(Ii) ignoring a second group of memory locations, each existing only in a particular computer of the computer where each memory location is physically located;
(Iii) promoting any memory location from the second group that a memory location in the first group starts to reference;
(Iv) replicating the promoted second group location to all other computers of the computer other than those physically located when in the second group;
(V) assigning the duplicated and promoted second group location to the first group;
(Vi) updating the first group location of another computer of the computer substantially simultaneously with any changes made to the first group location of any one of the computers;
Including methods. (Vii) Promoting any one or more memory locations referenced by the promoted second group memory location itself from the second group of memory locations, thereby causing the memory referenced by the promoted memory location A location includes an additional stage that inherits the promotion of its referenced memory location,
The method according to claim 1. (Viii) including the additional step of maintaining a table listing the first group of said memory locations;
The method according to claim 1 or 2, characterized in that (Ix) including the additional step of maintaining one said table for all said plurality of computers on another server computer;
The method according to claim 3. (X) including the additional step of maintaining one of the plurality of the tables in each of the plurality of computers;
The method according to claim 3. The memory location includes an asset, structure, or resource;
6. A method according to any one of claims 1-5. A multi-computer system in which different portions of at least one application program described to run only on a single computer are each executed substantially simultaneously on different corresponding computers of the plurality of computers,
Each of the plurality of computers has an independent local memory, all of the plurality of computers are interconnected by a communication network, and the memory locations present in the local memory are in two groups, each of which is A first group of memory locations that are replicated on each computer and a second group of memory locations that each exist only within a particular computer of the computer where each second group memory location physically exists Categorized, the system is
Memory updating means for updating any changes made to the first group of memory locations in one computer via the communication network to all other corresponding memory locations in the other computer;
Promotion means for promoting any of the memory locations of the second group currently referenced at the top by the memory locations of the first group as a result of execution of the application program from the second group to the first group;
A multi-computer system comprising: The promotion means includes inheritance means operable to promote any one or more memory locations referenced by the promoted second group memory location itself from the second group of memory locations.
The system according to claim 7. The promotion means includes a table listing a first group of the memory locations;
The system according to claim 7 or 8, characterized by the above. Having one table for all of the plurality of application program execution computers existing in another server computer;
The system according to claim 9. A plurality of the tables are provided in each of the plurality of application program execution computers.
The system according to claim 9. The memory location includes an asset, structure, or resource;
The system according to any one of claims 7 to 11, characterized in that: A set of program instructions stored in a storage medium and operable to allow a plurality of computers to perform the method of any one of claims 1-6.
A computer program product characterized by that.   A plurality of computers interconnected via a communication network and operable to reliably perform the method of any one of claims 1-6.   At least one other computer to perform the method of any one of claims 1 to 6 or to form a computer system according to any one of claims 7 to 12 and 14. A single computer adapted to work together.

Images