Method and apparatus for hardware coordination and resource management in distributed systems

Abstract

The system and method relate to a means and apparatus for transferring ownership of a common resource from a source entity that owns the resource to a destination entity that owns the resource in a distributed system. The method includes the source entity receiving a command to change ownership (MOVE command), and then marking that the source entity no longer owns the common resource. The source entity then sends the MOVE command to the destination entity, which then updates its table of common resource ownership to reflect that ownership of the common resource has been transferred from the source entity to the destination entity. It is advantageous that updating the ownership of the common resource in the source entity occurs simultaneously with assigning the MOVE command to the destination entity.

Description

[0001] Priority is claimed under 35 USC §119.

[0002] This patent application claims priority to non-provisional application No. 16 / 298,419, filed on March 11, 2019, entitled “HARDWARE CO-ORDINATION OF RESOURCE MANAGEMENT IN DISTRIBUTED SYSTEMS”, which is assigned to the assignee of this application and is expressly incorporated herein by reference. Technical Field

[0003] The disclosed aspects relate to distributed electronic systems, and more specifically, exemplary aspects relate to sharing resources in distributed electronic systems. Background Technology

[0004] With increasing advancements in electronics and packaging, functionality can be compressed into distributed systems. Since numerous independent electronic entities can be included in a distributed system, resource sharing among these entities is advantageous, for example, preventing unnecessary duplication of functional units. Effective resource sharing is also beneficial; for instance, the latency caused by such sharing is reduced.

[0005] Therefore, it is necessary to improve resource ownership management in distributed systems. Summary of the Invention

[0006] Exemplary aspects of the present invention relate to hardware, systems, and methods for managing resources in a distributed system.

[0007] In one embodiment, a method for use in an exemplary distributed system is disclosed, including a source entity and a destination entity. Each entity in the distributed system has a table recording ownership of public resources (i.e., which entity can access the public resource). Resources shared by the entities in the distributed system are public resources because more than one entity can access them, but only one entity can access a public resource at a time. The table of public resource ownership records which entities own (i.e., can access) the public resource. An entity that can access a public resource is said to own the resource, and any access to a public resource is performed by the entity that owns the public resource.

[0008] The method involves determining, from the source entity in the distributed system, that ownership (the right to access the public resource) of a public resource will be transferred to the destination entity. The method also includes updating the source entity's table of public resource ownership to reflect that the source entity no longer owns the public resource; and sending a MOVE command to another entity within the distributed system to reflect that ownership of the public resource has changed from the source entity to the destination entity.

[0009] In another embodiment, a method for controlling access to a public resource in an exemplary distributed system is disclosed. The method includes generating a request to access the public resource by a non-source entity (an entity that does not own the public resource). The method further includes sending an access request to a source entity, which generates the access to the public resource, and redirecting the result of the access to the public resource to the non-source entity.

[0010] In another embodiment, a method is disclosed for transferring ownership of a common resource in an exemplary distributed system when the source entity is unaware of the initiating entity, which owns the common resource. The initiating entity (the entity that generates the access request for access to the common resource) requests a transfer of ownership but is not the source entity. The method includes: accepting a MOVE command by the non-source initiating entity having a table of common resource ownership; having the initiating entity check the table of common resource ownership to determine which entity owns the common resource; and sending a MOVE command from the initiating entity to the source entity, indicating that a transfer of ownership of the common resource from the source entity to the destination entity is requested.

[0011] In another embodiment, a method for transferring a public resource in an exemplary distributed system is disclosed when a source entity that owns the public resource does not have ownership of the table containing the public resource. The method includes an entity that does not own the table containing the public resource accepting a MOVE command, the entity determining that it no longer owns the public resource, and sending a MOVE command from a non-source entity to at least one other entity, indicating that a transfer of ownership of the public resource from the public source entity to the destination entity is instructed.

[0012] In another embodiment, a method is disclosed for forwarding an access request and ownership of a public resource from a source entity to a destination entity. This method includes receiving an indication at the destination entity that ownership of the public resource will be moved from the source entity to the destination entity; and examining a sequence of commands in the source entity to determine whether an access request for the public resource and a MOVE command to transfer ownership of the public resource to the destination entity exist. If both the MOVE command and the access request exist, it is ensured that the MOVE command arrives at the destination entity before the access request arrives.

[0013] An apparatus for transferring ownership of a common resource in an exemplary distributed system is disclosed. The apparatus includes: an input for receiving an indication from a source entity that ownership of the common resource will be transferred; a table for updating ownership through the source entity to reflect that the source entity no longer owns ownership of the common resource; and circuitry for sending a MOVE command to another entity within the distributed system to reflect the change in ownership of the common resource from the source entity to the destination entity.

[0014] In another embodiment, an apparatus for controlling access to a public resource in a distributed system is disclosed. The apparatus includes: circuitry configured to generate a request for access to the public resource by a non-source entity; circuitry configured to transmit the access request to a source entity; circuitry configured to generate the access to the public resource by the source entity; and circuitry to direct the result of the access to the public resource to a non-source entity.

[0015] In another embodiment, an apparatus is disclosed for transferring ownership of a common resource in a distributed system when the source entity owns the common resource and the initiating entity requests a transfer of ownership. The apparatus includes: circuitry configured to receive a MOVE command from a non-source initiating entity that has a table of common resource ownership; circuitry configured to have the initiating entity examine the table of common resource ownership to determine which entity owns the common resource; and circuitry configured to send a MOVE command from the initiating entity to the source entity indicating ownership of the common resource, and to request a transfer from the source entity to the destination entity.

[0016] In another embodiment, an apparatus is disclosed configured to transfer ownership of a public resource in a distributed system when a source entity does not have ownership of the public resource in a table. The apparatus includes: a source entity circuitry configured to receive a MOVE command; an indicator indicating whether the source entity owns the public resource; a source circuitry configured to monitor whether the source entity owns the public resource; and a circuitry configured to send a MOVE command from a non-source entity to at least one other source entity, indicating that a transfer of ownership of the public resource from the source entity to the destination entity has occurred.

[0017] In another embodiment, an apparatus is disclosed for forwarding an access request and ownership of a public resource from a source entity to a destination entity. The apparatus includes: a circuitry configured to receive at the destination entity an indication that ownership of the public resource will be moved from the source entity to the destination entity; a source entity sequence for storing commands for the source entities before executing commands for the source entities; and a circuitry configured to examine the source entity command sequence to determine whether an access request for the public resource and a MOVE command to transfer ownership of the public resource to the destination entity exist. If both the MOVE command and the access request exist, the circuitry ensures that the MOVE command reaches the destination entity before the access request reaches the destination entity.

[0018] In another embodiment, an apparatus configured to transfer ownership of a common resource in an exemplary distributed system is disclosed. The apparatus includes: components for receiving an indication from a source entity that ownership of the common resource will be transferred to a destination entity; components for updating ownership by the source entity to reflect that the source entity no longer owns the common resource; and components for sending a MOVE command to another entity within the distributed system to reflect the change in ownership of the common resource from the source entity to the destination entity.

[0019] In another embodiment, a non-transitory computer-readable storage medium is disclosed, comprising code that, when executed by a processor, causes the processor to perform operations on a table for managing resource ownership in an exemplary distributed system. The encoding included in the non-transitory computer-readable storage medium includes: encoding for an indication that ownership of a public resource received by a source entity will be transferred; encoding for updating ownership by the source entity to reflect that the source entity no longer owns the public resource; and encoding for sending a MOVE command to another entity within the distributed system to reflect that the change in ownership of the public resource has been transferred from the source entity to the destination entity. Attached Figure Description

[0020] The accompanying drawings are presented to help describe aspects of embodiments of the invention, and the drawings are for illustrative purposes only and are not intended to limit the invention.

[0021] Figure 1 It is a simple, exemplary graphical representation of a distributed system;

[0022] Figure 2 It is a graphical representation of a part of an illustrative distributed system;

[0023] Figure 3 It is a graphical representation of the transfer of resource ownership between entities;

[0024] Figure 4 This is a flowchart illustrating the transfer of resource ownership between entities;

[0025] Figure 5 It is a graphical representation of part of an illustrative distributed system;

[0026] Figure 6 It is a graphical representation of part of an illustrative distributed system. Detailed Implementation

[0027] Various aspects of the invention are disclosed in the following description and accompanying drawings with respect to specific aspects of the invention. Alternative aspects may be designed without departing from the scope of the invention. Furthermore, elements well-known in the embodiments of the invention will not be described in detail or will be omitted so as not to obscure the relevant illustrative details taught herein.

[0028] The word “exemplary” is used herein to mean “as an example, instance, or illustration.” Any aspect described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other aspects. Similarly, the term “specific aspect of the invention” does not require that all aspects of the invention include the features, advantages, or modes of operation discussed.

[0029] The terminology used herein is for the purpose of describing particular aspects only and is not intended to be limiting of aspects of the invention. As used herein, the singular forms “a,” “an,” and “the” are also intended to include the plural forms unless expressly indicated otherwise. It will be further understood that the terms “comprises,” “comprising,” “includes,” and / or “including” as used herein specify the stated features, integers, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or combinations thereof.

[0030] Furthermore, many aspects are described according to sequences of actions to be performed by elements, such as computing devices. It will be appreciated that the various actions described herein can be performed by specific circuitry (e.g., an application-specific integrated circuit (ASIC)), program instructions executed by one or more processors, or a combination of both. Additionally, the sequences of actions described herein can be considered fully embodied in any form of computer-readable storage medium storing a corresponding set of computer instructions that, when executed, will cause the associated processor to perform the functionality described herein. Therefore, various aspects of the invention can be embodied in many different forms, all of which are contemplated within the scope of the claimed subject matter. Furthermore, for each aspect described herein, any corresponding form of any such aspect can be described herein as, for example, "logically configured to" perform the described actions.

[0031] For the purposes of this disclosure, a distributed system includes, but is not limited to, electronic entities (entities), including, but not limited to, inputs for receiving information, outputs for transmitting information, and messaging mechanisms for communicating with other entities. The inputs for receiving information and the outputs for communicating with other entities, as well as the messaging bus, can in fact be the same physical connection, for example, a serial or parallel bus that serves as both input or output, but they are not required to be.

[0032] For the purposes of this disclosure, a shared resource (resource) is defined as a shared device (e.g., a memory table, floating-point unit, input / output unit, register, etc.) used by different entities at different times. For example, a shared resource can be accessed by different threads in a multi-threaded computing environment.

[0033] For the purposes of this disclosure, an owner is defined as a singular, optional access controller that acts as a gateway to a shared resource. Ownership (and non-ownership) may be included in the entity's public resource ownership table (though not required) so that the entity can know whether it has access to the shared resource. Once the shared resource is owned, the owner entity can access or authorize access to the shared resource.

[0034] For the purposes of this disclosure, access is defined as any operation that requires communication, such as writing to or reading from a public resource.

[0035] For the purposes of this disclosure, a MOVE command is an order to transfer ownership of a shared resource from one entity to another. A MOVE command includes an identifier of the shared resource and an indication of the entity to which ownership of the shared resource will be transferred, although it may also include other information.

[0036] For the purposes of this disclosure, the source entity is an entity that owns public resources.

[0037] For the purposes of this disclosure, the destination entity is the entity to which ownership of the public resource will be transferred.

[0038] For the purposes of this disclosure, the initiating entity is a non-source and non-destination entity that can initiate a MOVE command.

[0039] For the purposes of this disclosure, the table of public resource ownership (also known as the public source table, the table of public ownership, and the table of resource ownership) is a list of entities that currently own public resources.

[0040] Figure 1 This is a simple, exemplary graphical representation of a distributed system. Typically, a distributed system is a system where computing resources are decentralized to multiple entities that collaborate to function properly. Such collaboration is accomplished through mechanisms that allow information to be exchanged between entities. Figure 1 The system in the example is a simple distributed system. Figure 1 Component 101 (an exemplary portion of the distributed system) is shown, comprising different semiconductor dies 103, 109a, 109b, 109c, 115a, 115b, and 115c on a load substrate 102. Figure 1In this configuration, three CPU (Central Processing Unit) dies 115a, 115b, and 115c are coupled to three memory management unit dies 109a, 109b, and 109c, respectively, via three interconnecting buses 113a, 113b, and 113c. The three memory management unit dies 109a, 109b, and 109c are also coupled to a memory die 103 via a memory bus 107. Memory die 103 includes a table 105 accessed by the three CPU dies 115a, 115b, and 115c. Since there is only one table 105, CPU dies 115a, 115b, and 115c must access table 105 in turn. Access to table 105 is mediated over a message passing bus 111. Memory management unit dies 109a, 109b, and 109c share ownership and transfer ownership of table 105 using message passing bus 111. One way to control ownership (allowing reading from or writing to a common resource used by multiple entities) is to maintain a table within each entity listing each entity and which entity owns the common resource and is therefore allowed access to it. Such a table is considered, in this document, to be a table of common resource ownership. Only the owner of table 105—the source entity—can access it at any given time; therefore, access to table 105 is managed using a message passing bus 111. Such a message passing “bus” can be a serial or parallel bus as represented by message passing bus 111, or it can be some kind of virtual channel. The mechanism capable of passing information between entities is considered, here, a message passing “bus.”

[0041] When multiple entities, such as memory management unit dies 109a, 109b, and 109c, read from and write to a shared resource, such as table 105, there is a possibility that the system may slow down because one memory management entity must wait for another entity to finish using the shared resource. If the waiting time for the shared resource exceeds a certain limit, the system will run slower. Therefore, rapid transfer of resource ownership is beneficial. However, rapid transfer of ownership can lead to race conditions and resource corruption if one entity interrupts another entity's data (e.g., if data assigned to one entity is interrupted by a second entity because it belongs to another entity) or in a contention situation where more than one MMU 109 attempts to access table 105 simultaneously. When two or more entities want to access a shared resource simultaneously, reducing the time allocated for transferring source ownership may increase the likelihood of race conditions between entities, which exacerbates the resource corruption problem.

[0042] like Figure 1The distributed system example shown is one example of a distributed system. An unlimited number of different distributed systems can be designed virtually. The current example is included to provide a concrete, easy-to-understand system example where multiple entities collaborate via a message bus 111 to access a common resource table 105.

[0043] Figure 2 This is a graphical representation of part 201 of another illustrative distributed system. In distributed system 201, memory table 203 is written to and read from by four computational entities: entity 1 (205a), entity 2 (205b), entity 3 (205c), and entity 4 (205d). Entities 205a-205d communicate with each other via message passing bus 207, which can be any type of channel known in the art capable of transmitting messages between entities, such as a serial bus, parallel bus, or virtual channel.

[0044] exist Figure 2 In this example, entity 1 (205a) initially owns memory table 203. However, memory table 203 is a publicly owned resource, and its information is relevant to all entities 205a-205d in the illustrative distributed system 201. If entity 1 (205a) is the owner of the publicly owned resource (memory table 203), then none of the other entities 205b-205d are permitted to access memory table 203. If an entity requests access from memory table 203, it can forward the access request to the resource owner entity 1 (205a) because entity 1 (205a) owns memory table 203, and generally no other simultaneous access to memory table 203 is permitted, for example, to protect data continuity. For illustrative purposes, only the owner of the resource (e.g., the source entity) will access the resource, and if other entities request data in the public resource, they will submit an access request to the current public resource owner to obtain access to that public resource.

[0045] System software (not shown) can reveal changes in ownership of public resources. Such transfers of ownership can improve system performance in many situations.

[0046] The transfer of ownership from one entity to another can cause memory continuity problems, for example, if two entities attempt to write to the same location in memory table 203 simultaneously. Such situations are often referred to as race conditions. Race conditions are difficult to resolve because they can intermittently corrupt data depending on a variety of factors. Therefore, it is advantageous to prevent such race conditions by ensuring that only the owner of the resource can access it.

[0047] A simple yet effective method to avoid race conditions during ownership transfers is to suspend entity access. In other words, when ownership of a common resource needs to change, race conditions can be avoided by simply halting all entity access (e.g., reading from or writing to the common resource) until the ownership transfer is complete. This method, of course, has a significant drawback: all access to the common resource is halted, whether necessary or not.

[0048] Figure 3 This is a diagrammatic illustration of the transfer of resource ownership between entities. This method involves transferring resource ownership, resolving the race conditions described above without inefficiently deferred entities in the system. Figure 3 In this context, entities 1 to 4 (305a to 305d respectively) are all entities that may need to access public resource 311. Entities 305a-305d pass messages via any suitable type of message bus (not shown) to share access to public resource 311 by transferring ownership of the resource.

[0049] The first step in the transfer of ownership of a resource to be transferred (e.g., public resource 311) is to update the ownership in its public resource ownership table 313 for the source entity (which owns the resource). The public resource ownership table (e.g., 313) is a list of entities in the system and what public resources each entity owns (can access). Each entity may include a public resource ownership table with the same information. The public resource ownership table 313 will be updated to reflect the relinquishment of ownership by source entity 1 (305a) to destination entity 305b (i.e., entity 2). Updating the public resource ownership table in the source entity before any other entity updates its own table helps avoid race conditions. Figure 3 Each entity 305a-305d in the table has a table of public resource ownership, similar to Table 313 of public resource ownership, which records the entities that currently own the resources. The tables of public resource ownership in entities 3 and 4 are not shown to avoid confusion. Figure 3 To avoid unnecessary confusion, in the current example, entity 1 (305a) owns public resource 311. To transfer ownership of public resource 311, entity 1 (305a) updates its public resource ownership table 313 to reflect that it is no longer the owner of public resource 311, and that the destination entity 305b is the new owner. Any access requests to public resource 311 that currently arrive at entity 1 (305a) will be forwarded to the new owner, as reflected in entity 1 (305a)'s public resource ownership table 313.

[0050] Then, once entity 1 (305a) can execute the command and update its public resource ownership table 315, entity 1 (305a) sends a MOVE command 307a to the destination entity 305b, which will become the new owner of public resource 311. The MOVE command is also sent to other entities in the system so that their public resource ownership tables can be appropriately updated with the new public resource ownership. The change of ownership should be as close as possible to the primitive operation; that is, the change of ownership reflected in public resource ownership should occur simultaneously with the sending of MOVE commands to other entities (e.g., 307a, 311a, and 309a). However, if such a primitive operation is not possible for some reason, the change of ownership should be reflected in the source entity's common resource ownership table before the MOVE command is executed by any other entity, to ensure "thread-safe" operation and thus ensure that one thread does not corrupt the data of other threads. Once each entity has changed its resource ownership table, it can report back to the source entity that the MOVE command has been executed (e.g., 307b, 309b, and 311b can report that their common resource ownership tables have been updated).

[0051] Figure 4 It is a flowchart illustrating the transfer of resource ownership between entities, generally presented in 401.

[0052] In block diagram 403, the source entity 305a, which currently owns the public resource 311, receives a MOVE command from another entity (e.g., 305b, the destination entity). The next decision block diagram 405 is then executed.

[0053] In decision diagram 405, source entity 305a determines whether public resource 311 has completed access to the public resource. If source entity 305a has not completed access to public resource 311, diagram 405 will continue to be executed. If source entity 305a has completed the use of public resource 311, the process will proceed to diagram 407.

[0054] In block diagram 407, source entity 305a transfers ownership by updating its public resource ownership table 313 to reflect the fact that destination entity 305b owns public resource 311. One way to control ownership is to maintain an ownership table within each entity that lists each public resource and which entity owns it, and is therefore allowed to read from or write to (i.e., access) the public resource. In a simpler system, for example, for an entity accessing only one public resource, the public resource ownership table can be replaced by an indicator of whether an entity owns the public resource. In the present, more complex exemplary system, source entity 305a transfers ownership by noting in its public resource ownership table 313 that public resource 311 is owned by destination entity 305b. Control then moves to block diagram 409.

[0055] In block diagram 409, the source entity sends a MOVE command to (also considered a MOVE command) the destination entity 305b, and then block diagram 411 is executed.

[0056] In block diagram 411, destination entity 305b receives the MOVE command and then updates its internal public resource ownership to reflect that destination entity 305b is now the owner of public resource 311. Block diagram 413 is then executed.

[0057] In block diagram 413, destination entity 305b checks its public resource table to determine whether it currently owns public resource 311. If destination entity 305b no longer owns public resource 311, block diagram 415 is then executed.

[0058] In block diagram 415, destination entity 305b forwards any access request from the public resource to the source entity back to the source entity, and then executes block diagram 413.

[0059] Of course, if source entity 305a receives arbitrary data from a public resource, it will check its public resource table 313, and once it determines that the public resource table indicates that the public resource belongs to destination entity 305b, it will forward the data to destination entity 305b. This ping-ponging process between diagrams 413 and 415 will be broken in diagram 413 when the public resource ownership table 313 of destination 305b is updated to show that destination entity 305b is the owner of public resource 311. Then, step 417 will be executed.

[0060] In block diagram 417, destination entity 305b has ownership of public resource 311, which is reflected in table 315 of public resource ownership, and destination entity 305b can begin to access public resource 311.

[0061] Figure 5 It is part of an illustrative distributed system's 501 graphical representation. Typically, software running in a distributed system knows which entity owns a specific shared resource. Figure 5 The diagram illustrates a scenario where software executing in a first entity of a distributed system is unaware of which entity owns a specific public resource. In such a case, a MOVE command can be sent to a second entity, for example, by coupling the first entity to a message bus. If the second entity does not own the public resource to which the MOVE command is the subject, the receiving second entity will attempt to forward it to the entity that owns the specific public resource. If the receiving second entity owns the public resource, it will execute the MOVE command and relinquish ownership of the public resource.

[0062] exist Figure 5 The graphical representation shows four entities: 505a, 505b, 505c, and 505d. Each entity has a table of common resource ownership, 503a, 503b, 503c, and 503d, respectively.

[0063] Assume, for illustrative purposes, that a MOVE command is sent to entity 3 (505c), which is not the current owner of the public resource whose ownership will be moved. Entity 3 can be considered the initiating entity because it is where the MOVE command is initially sent (i.e., initiated). Assuming entity 1 (505a) is the entity that owns the public resource (i.e., the source entity), entity 3 should not be the first to change its mapping in its public resource table 503c. Once entity 3 (505c) (the initiating entity) checks its public resource ownership table 503c, it will determine, for example, that entity 1 (505a) is the current owner (source entity) of the public resource whose ownership will be moved. Entity 3 (505c) will then send a MOVE FWD request 507b to entity 1 (505a). Once entity 1 receives the MOVE FWD request 507b, it will update its public resource ownership table 503a to reflect the movement of public resource ownership to the destination entity 505b. Subsequently, once entity 1 (505a) has updated its public resource ownership table 503a, entity 1 (505a) can then send MOVE commands to entities 2, 3, and 4, as shown in 509b, 507c, and 509d, so that they can update the ownership of the transferred resources in their public resource ownership tables 503b, 503c, and 503d. Once entities 2, 3, and 4 have updated their public resource tables, they can send MOVE CMPLT (MOVE complete) commands (509c, 511, and 507d) to the source entity of the MOVE command, in example entity 3 (505c). Once entity 1 (505a), which requested the change of ownership, receives the MOVE CMPLT commands (509c, 511, and 507d) from the other entities in the distributed system, it can notify that the request for a change of ownership of the software public resources has been completed.

[0064] In some cases, entities may not need to own certain public resources, and in some cases, may not even have a table indicating ownership of public resources. For example, an entity that only accesses a printer will not need a table indicating resource ownership; the entity would need to indicate whether it currently owns the printer. In the current example entity 3 (505c), such an entity can respond to a MOVE command by sending a “dummy” MOVE CMPLT command to the entity requested to move.

[0065] Example scenarios where the source entity does not have ownership of a table for a public resource can arise, for example, if an entity only accesses one public resource and has no access to other public resources. As in the example above, where the entity accesses only one public resource, a printer, entities that do not have ownership of public resources within the system could exist because they access only a single public resource. The entity does not need to keep track of public resources it does not use.

[0066] For example, suppose the source entity is Entity 1 (505a) and there is no table 503a for public resource ownership. A mechanism is needed to handle this situation. Again, Entity 3 (503c), the initiating entity, receives the MOVE command and forwards it to the source entity Entity 1 (505a). Although Entity 1 (505a) does not have a table for public resource ownership, as the source entity, it still coordinates with the public resource transfer. Once the source entity 505a receives the MOVE command from the requesting entity 505c, the source entity 505a can mark the public resource as no longer available to it and create a temporary marker (not shown). The source entity 505a can then send MOVE commands (e.g., 509b, 509d, and 507c). Once the requesting entity 505c receives all the MOVE CMPLT signals (509c, 511, and 507d) from all other entities in the system, it can then inform the source entity 505a that the transfer of resource ownership has been completed and send a MOVE CMPLT command 507a to the source entity 505a to indicate that the transfer of ownership has been completed, and that entity 1 (505a) can move the temporary resource map. In this case, the temporary resource map is able to record the entities in the system and whether they responded to the MOVE commands (e.g., 509b, 509d, and 507c) and sent MOVE CMPLT commands (509c, 511, and 507d) to the source entity, and, if necessary, to the initiating entity.

[0067] Figure 6 It is a graphical representation of part 601 of an illustrative distributed system. Figure 6 The diagram shows four entities: Entity 1 (605a), Entity 2 (605b), Entity 3 (605c), and Entity 4 (605d).

[0068] Entity 1 (605a) is the source entity. Entity 1 (605a) includes command sequence 607. Command sequence 607 includes commands to be executed by entity 1 (605a), such as transfer commands, which may be in no particular order.

[0069] For example, such as Figure 5As shown, assume that entity 1 (605a) receives a request to access a public resource that will be accessed by entity 2 (605b). It is also assumed that table 603a of public resource ownership indicates that entity 1 (605a) is the current owner of the resource to be accessed by entity 2 (605b). At some point, we can assume that entity 1's command sequence 607 will include an access request 611 for entity 2 (605b) to access public resource 615. Entity 1 (605a) understands that it must send access request 611 to entity 2 (605b). At some point, entity 1 (605a) will also determine that entity 1 is the owner of public resource 615 and generate a MOVE command 609 to move public resource 615 to entity 2 (605b). It is entirely possible that access request 611 is scheduled to be transmitted to entity 2 (605b) prior to MOVE command 609. If access request 611 arrives at entity 2 (605b) before MOVE command 609, then the destination of entity 2 (605b) will simply forward access request 611 back to entity 1 (605a), as shown in Figure 613. However, it would be more efficient for entity 1 (605a) to detect that it will send both the first access request 611 and MOVE command 609 for publicly owned resource 615 to the public entity than to send MOVE command 609 first.

[0070] If access request 611 is sent to destination entity 605b before the MOVE command is sent to destination entity 605b, destination entity 605b can check its public resource ownership table 603b and determine that public resource 615 is owned by source entity 605a, and forward access request 611 to the previous owner of public resource 615 (in this case, source entity 605a). However, if MOVE request 609 is sent from source entity 605a before access request 611, destination entity 605b will update its public resource ownership table before receiving access request 611. Destination entity 605b will then determine that it owns public resource 615 and that access to public resource 615 is free.

[0071] In this scenario, access request 611 is sent to destination entity 605b prior to MOVE command 609, and access request 611 will be forwarded back to source entity 605a at 613. Source entity 605a will check its public resource ownership table 603a and then forward access request 611 back to destination entity 605b (i.e., entity 2). Accordingly, if entity 1 (605a) detects both MOVE command 609, which transfers ownership of a public resource to destination entity 605b, and access request 611, which represents the public resource of destination entity 605b in command sequence 607, it is beneficial for entity 1 (605a) to ensure that MOVE command 609 is sent and reaches destination entity 605b before access request 611 arrives at destination entity 605b. This will ensure that destination entity 605b has updated its public resource ownership table 603b. Once ownership of public resource 615 has been transferred by source entity 605a, destination entity 605 updates its public resource ownership table 603b, and destination entity 605b owns the public resource. Once destination entity 605b owns public resource 615, it will complete access request 611 and will no longer forward access requests in 613.

[0072] Those skilled in the art will understand that information and signals can be represented using any variety of different technologies and techniques. For example, data, instructions, commands, information, signals, bits, symbols, and chips can be represented by voltage, current, electromagnetic waves, magnetic fields or magnetic particles, light fields or light particles, or combinations thereof, as described above.

[0073] Furthermore, various exemplary logic diagrams, modules, circuits, and algorithmic steps that can be associated with aspects of the present invention can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate such interchangeable hardware and software, the various illustrative components, modules, circuits, and steps described above can be generalized in terms of their functionality. Whether this functionality is implemented as hardware or software depends on the specific application and the design constraints imposed on the system as a whole. Those skilled in the art can implement the described functionality in different ways for each specific application, but such implementation decisions should not be construed as departing from the scope of the invention.

[0074] The methods, sequences, and / or algorithms associated with the aspects disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or a combination of both. The software module may reside in RAM registers, flash memory, ROM memory, EPROM memory, registers, hard disks, removable hard disks, CD-ROMs, or any other form of storage medium known in the art. Exemplary storage media are coupled to the processor such that the processor can read information from or write information to the storage medium. Alternatively, the storage medium may be integrated into the processor.

[0075] Therefore, one aspect of the invention may include a computer-readable non-transitory medium implementing a method for managing cache allocation. Consequently, the invention is not limited to the illustrated examples, and any means for performing the functionality described herein are included in aspects of the invention.

[0076] While the foregoing disclosure has illustrated illustrative aspects of the invention, it should be noted that various changes and modifications may be made herein without departing from the scope of the invention as defined by the appended claims. Furthermore, although elements of the invention may be described or claimed in the singular, the plural forms are also encompassed unless expressly stated to be limited to the singular.

Claims

1. A method for a distributed system, the distributed system comprising a plurality of entities, the plurality of entities including source entities and destination entities, wherein each entity has a table of common resource ownership, wherein the table of common resource ownership is a list of the plurality of entities and indicates which of the plurality of entities currently owns which common resource, and wherein each table of common resource ownership of the plurality of entities includes the same information, the method comprising: The ownership of the public resource will be transferred to the destination entity, as determined by the source entity that owns the public resource. The source entity updates its table of ownership of the public resource to reflect that the source entity no longer owns the public resource; as well as After the source entity updates its table of ownership of the public resource, it sends a corresponding MOVE command to the destination entity and all other entities among the plurality of entities, reflecting that the ownership of the public resource has changed from the source entity to the destination entity.

2. The method of claim 1, wherein updating the table of ownership of the public resource further includes instructing the destination entity to own the public resource.

3. The method of claim 2, further comprising sending a MOVE command to at least one non-source entity, indicating that ownership of the public resource has changed from the source entity to the destination entity.

4. The method of claim 3, wherein the method further comprises sending confirmation from at least one non-source entity that ownership of the public resource has been changed from the source entity to the destination entity.

5. A method for transferring ownership of a public resource in a distributed system when a source entity is unaware of an initiating entity, the source entity owning the public resource, the initiating entity requesting a transfer of ownership, wherein the distributed system comprises multiple entities, the multiple entities including the source entity and a destination entity, wherein each entity has a table of public resource ownership, wherein the table of public resource ownership is a list of the multiple entities and indicates which of the multiple entities currently owns which public resource, and wherein each table of public resource ownership for the multiple entities includes the same information, the method comprising: The MOVE command is received by a non-source initiating entity that owns a table that has public resource ownership. The initiating entity examines the table of ownership of the public resource to determine which entity owns the public resource; as well as The initiating entity sends a MOVE command to the source entity, indicating that a transfer of ownership of the public resource from the source entity to the destination entity is requested.

6. The method according to claim 5, further comprising: The source entity sends a MOVE command to at least one non-source entity, indicating that ownership of the public resource has been moved from the source entity to the destination entity.

7. The method according to claim 6, further comprising: The non-source initiating entity receives the MOVE command from the source entity; as well as The notification to the non-originating entity indicates that ownership of the public resource has been transferred to the destination entity.

8. The method of claim 7, wherein notifying the non-source initiating entity that ownership of the public resource has been transferred to the destination entity comprises: The destination entity sends a MOVE CMPLT back to the non-source initiating entity.

9. A method for transferring ownership of a public resource in a distributed system when a source entity does not have a table of public resource ownership, the distributed system comprising multiple entities, the multiple entities including the source entity and a destination entity, wherein the table of public resource ownership is a list of the multiple entities and indicates which of the multiple entities currently owns which public resource, and wherein each of the multiple entities' tables of public resource ownership includes the same information, the source entity owning the public resource, the method comprising: The MOVE command is accepted by an entity that does not own the table of the public resource; The entity that does not have ownership of the public resource determines that it no longer owns the public resource. as well as A MOVE command is sent from a non-source entity to at least one other entity, indicating that the transfer of ownership of the public resource from the source entity to the destination entity is instructed.

10. The method of claim 9, further comprising: A temporary table is created by the entity that does not have ownership of the public resource. The temporary table indicates ownership of the public resource by other entities and indicates whether the other entities have responded to the MOVE command and have access to the public resource. When an entity confirms that the MOVE command comes from an entity that does not have ownership of a public resource, it marks the entry in the temporary table as having moved ownership of the public resource from the source entity to the destination entity.

11. The method of claim 10, further comprising moving the temporary table once all entities having access to the public resource respond to the MOVE command with a MOVE CMPLT command, the MOVE CMPLT command indicating to the destination entity that the ownership of the public resource has been updated from the source entity to the destination entity.

12. A method for forwarding access requests and ownership of common resources from a source entity that owns the common resources to a destination entity in a distributed system, said distributed system comprising multiple entities, said multiple entities including a source entity and a destination entity, said method comprising: At the destination entity, receive an instruction that ownership of the public resource will be moved from the source entity to the destination entity; as well as The source entity command sequence is examined to determine whether there is an access request for the public resource to the destination entity and a MOVE command to transfer ownership of the public resource to the destination entity. If both the access request and the MOVE command exist, the MOVE command is ensured to arrive at the destination entity before the access request arrives at the destination entity.

13. The method of claim 12, wherein ensuring that the MOVE command reaches the destination entity before the access request reaches the destination entity further comprises: The MOVE command is transferred to the destination entity on the message bus before the access request is transferred to the destination entity.

14. An apparatus for a distributed system, the distributed system comprising a plurality of entities, the plurality of entities including a source entity and a destination entity, wherein a table of public resource ownership is a list of the plurality of entities and indicates which of the plurality of entities currently owns which public resource, and wherein each of the plurality of entities has a table of public resource ownership including the same information, wherein each entity has a table of public resource ownership, the apparatus comprising: At least one processor; as well as A memory coupled to the at least one processor, the memory including instructions executable by the at least one processor to cause the device to perform the following operations: The ownership of the public resource will be transferred to the destination entity, as determined by the source entity that owns the public resource. The source entity updates its table of ownership of the public resource to reflect that the source entity no longer owns the public resource; as well as After the source entity updates its table of ownership of the public resource, it sends a corresponding MOVE command to the destination entity and all other entities among the plurality of entities, reflecting that the ownership of the public resource has changed from the source entity to the destination entity.

15. The apparatus of claim 14, wherein the memory further comprises instructions executable by the at least one processor to cause the apparatus to perform the method according to any one of claims 2-4.

16. An apparatus in a distributed system for transferring ownership of a public resource when a source entity is unaware of an initiating entity, the source entity owning the public resource, the initiating entity requesting a transfer of ownership, wherein the distributed system comprises a plurality of entities, the plurality of entities including the source entity and a destination entity, wherein each entity has a table of public resource ownership, wherein the table of public resource ownership is a list of the plurality of entities and indicates which of the plurality of entities currently owns which public resource, and wherein each table of public resource ownership of the plurality of entities includes the same information, the apparatus comprising: At least one processor; as well as A memory coupled to the at least one processor, the memory including instructions executable by the at least one processor to cause the device to perform the following operations: The MOVE command is received by a non-source initiating entity that owns a table that has public resource ownership. The initiating entity examines the table of ownership of the public resource to determine which entity owns the public resource; as well as The initiating entity sends a MOVE command to the source entity, indicating that a transfer of ownership of the public resource from the source entity to the destination entity is requested.

17. The apparatus of claim 16, wherein the memory further comprises instructions executable by the at least one processor to cause the apparatus to perform the method of any one of claims 6-7.

18. An apparatus for transferring ownership of a public resource in a distributed system when a source entity does not have a table of public resource ownership, the source entity owning the public resource, the distributed system comprising a plurality of entities, the plurality of entities including the source entity and a destination entity, wherein the table of public resource ownership is a list of the plurality of entities and indicates which of the plurality of entities currently owns which public resource, and wherein each public resource ownership table of the plurality of entities includes the same information, the apparatus comprising: At least one processor; as well as A memory coupled to the at least one processor, the memory including instructions executable by the at least one processor to cause the device to perform the following operations: The MOVE command is accepted by an entity that does not own the table of the public resource; The entity that does not have ownership of the public resource determines that it no longer owns the public resource. as well as A MOVE command is sent from a non-source entity to at least one other entity, indicating that the transfer of ownership of the public resource from the source entity to the destination entity is instructed.

19. The apparatus of claim 18, wherein the memory further comprises instructions executable by the at least one processor to cause the apparatus to perform the method according to any one of claims 9-10.

20. An apparatus for forwarding access requests and ownership of common resources from a source entity that owns the common resources to a destination entity in a distributed system, the distributed system comprising a plurality of entities, the plurality of entities including a source entity and a destination entity, the apparatus comprising: At least one processor; as well as A memory coupled to the at least one processor, the memory including instructions executable by the at least one processor to cause the device to perform the following operations: Receive at the destination entity an instruction that ownership of the public resource will be moved from the source entity to the destination entity; and The source entity command sequence is examined to determine whether there is an access request for the public resource to the destination entity and a MOVE command to transfer ownership of the public resource to the destination entity. If both the access request and the MOVE command exist, the MOVE command is ensured to arrive at the destination entity before the access request arrives at the destination entity.

21. The apparatus of claim 20, wherein the memory further comprises instructions executable by the at least one processor to cause the apparatus to perform the method according to any one of claims 12-13.

Images