|Publication number||US7877515 B2|
|Application number||US 12/124,633|
|Publication date||Jan 25, 2011|
|Filing date||May 21, 2008|
|Priority date||May 21, 2008|
|Also published as||EP2304561A1, US20090292712, WO2009141793A1|
|Publication number||12124633, 124633, US 7877515 B2, US 7877515B2, US-B2-7877515, US7877515 B2, US7877515B2|
|Inventors||Per Andersson, Jon Paul Maloy, Suresh Krishnan|
|Original Assignee||Telefonaktiebolaget L M Ericsson (Publ)|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (5), Non-Patent Citations (1), Referenced by (6), Classifications (7), Legal Events (2)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present invention generally relates to data processing systems and methods, devices and software and, more particularly, to mechanisms and techniques for assigning identities to software components.
Most software applications are physically or logically split into separate components, which components need to intercommunicate via some communication protocol when the applications are executed. In order to achieve this intercommunication, each component needs to be able to identify other components, using some identity scheme. Such identity types are often application specific, and typically differ from the addressing scheme provided by the communication protocol which is used.
Assigning functional identities to software components is an important task, since designers typically want to build desirable properties into the assignment scheme. For example, a designer may typically prefer that the assignment scheme enable the number of software components to be extendable or shrinkable, without affecting the clients' (which are often just other components of the same application) ability to send messages to the components. Moreover, the designer may want to control the distribution of traffic towards the components, e.g., because some components are running on more powerful CPUs than others. Additionally, the designer may want to limit disturbances to the system during reconfiguration, e.g., state transfers between components, or usage of bandwidth and memory during advertisement of the identities.
A straightforward assignment scheme involves assigning a single identity to each software component 10, e.g., identity “0” to component A, identity “1” to component B, etc., as shown for example in
Another identity assignment scheme is illustrated in
Thus it will be appreciated that the identity assignment schemes discussed above may suffer from, for examples issues associated with scalability and/or traffic continuity during a redistribution of identities. Accordingly, it would be desirable to provide systems, methods, devices and software for assignment of identities to software components which avoid the afore-described problems and drawbacks.
According to one exemplary embodiment, a method for assigning identities to components of a software application includes assigning a plurality of identities to each of the components, and redistributing the identities while continuing to permit traffic between the components and one or more clients.
According to another exemplary embodiment, a processing node for assigning identities to components of a software application includes at least one processor configured to assign a plurality of identities to each of the components and to redistribute the identities while continuing to permit traffic between the components and one or more clients, and a memory for storing the redistributed identities in a table.
According to still another exemplary embodiment, a computer-readable medium contains program instructions stored thereon which, when executed by a computer or processor, performs the steps of assigning a plurality of identities to each of the components, and redistributing the identities while continuing to permit traffic between the components and one or more clients.
The accompanying drawings, which are incorporated in and constitute a part of the specification, illustrate one or more embodiments and, together with the description, explain these embodiments. In the drawings:
The following description of the exemplary embodiments of the present invention refers to the accompanying drawings. The same reference numbers in different drawings identify the same or similar elements. The following detailed description does not limit the invention. Instead, the scope of the invention is defined by the appended claims.
As suggested above, one problem with the assignment scheme illustrated in
According to a first exemplary embodiment, an identity assignment scheme is provided which drastically reduces the problems described above, while retaining the basic properties of simplicity and scalability. According to this exemplary embodiment an Ri>>N distribution pattern is provided with a dynamic (variable) value range that can be accommodated by improving the hashing algorithm on the clients. Thus, unlike the identity assignment schemes described in
According to exemplary embodiments, the number of identities in the identity space, Ri, is typically selected to be at least an order of magnitude bigger than the number of components 30, but small enough to keep table sizes and state transfers during reconfiguration to a reasonable minimum. The value for n can, for example, be selected as N<=Rc <=4N. The higher the value of n, the better the distribution of identities as will be seen in the following examples. The value for m can, for example, be expressed as comes out as a function of Ri and n, e.g., (2m=Ri/Rc=Ri/(2*n)), such that the container size is a function of the number of identities and the number of containers. Ri and n are preferably selected so that m becomes an integer value. An exemplary interrelationship between these values for an identity assignment scheme according to this first exemplary embodiment can be expressed as:
Once distributed, those components which have new identities associated therewith can advertise (broadcast) their new identities via a communication interconnect 36 (e.g., bus, pipeline, etc.) so that client(s) 34 can store the correlation between the new identities and that component in a table 38. According to some exemplary embodiments, a client 34 can also be considered to be any addressable functional entity, e.g., a physical or logical (e.g., running on a virtual machine) computer or processing entity including, for example, a server which is associated with an identity distribution scheme, that uses services provided by the component(s) 30. The client 34 uses its stored version of the current mapping between identities and components 30 to select a particular component 30 to receive, e.g., an outgoing message. For example, as shown in
During the lifecycle of a software application having a number of different components 30 it may be desirable to increase the number of identities which are used to identify those components 30, e.g., in order to prepare for a redistribution of identities associated with an anticipated change in the relative workloads of the various components 30. This can be accomplished by multiplying the global identity space Ri by, for example, a factor of two, which implies that each component 30 shall double the size of its containers 32 and add the new identity values to those containers which were created to reach the new identity value limit. An example of identity number expansion according to this exemplary embodiment for the identity assignment scheme of
The identity expansion described above with respect to
Moreover, expanding the identity space according to this exemplary embodiment may also be a preparative step for removing one or more components 30 from a system. For example, if an odd, low number of components 30 currently exists in a given identity assignment scheme according to these exemplary embodiments, it may be difficult to obtain a fair distribution of identities unless there are a sufficient number of containers 32. To illustrate this point, consider first the exemplary component removal scenario shown in
The foregoing exemplary embodiment permits the ready expansion or contraction of the identity space through the use of a variable number of identities grouped into logical containers. Expansion or contraction of the identify space can be performed with minimal effect on the client applications, e.g., traffic can continue to be sent by the client(s) 34 to the component(s) 30 during the same time that the identity space is being expanded or contracted. Scalability according to these exemplary embodiments also comes with the capability to create and maintain an optimal load distribution profile, e.g., with respect to user traffic profiles and/or the number of server component. Alternatively, however, other exemplary embodiments provide for scalability and minimal impact on client operations using a fixed number of identities as will now be described with respect to
Like the previous exemplary embodiment, this exemplary embodiment uses a number of identities Ri which is much greater than a number N of components being addressed, however the identity range Ri is fixed rather than variable. This, in turn, permits a fixed (i.e., non-parameterized) hashing function to be used by a client to select a target identity for delivery of an outgoing message. This exemplary embodiment manipulates, advertises and stores identity sequences, handled as, for example, an [upper_limit . . lower_limit] tuple, instead of individual identities grouped in containers.
Selection of a particular identity among those in the identity space for delivery of a message or call from a client 44 to a respective component 40 can be performed as shown, for example, in
Equal load balancing between the components 40 may not always be desirable. For example, one component 40 may be running on a more powerful CPU than the other components, and hence can handle more traffic. Additionally, the traffic distribution itself, with regard to the identities used, may also be unbalanced, leading to a desire to compensate for the imbalance. This compensation can be performed by redistributing the identities among the components 40 which, for this exemplary embodiment, means shrinking some sequences 42 and expanding other sequences 42. An example of identity redistribution for this exemplary embodiment is illustrated in
One or more new components 40 can be added using the identity assignment scheme of
Similarly, removal (or loss) of a component 40 can be handled according to this exemplary embodiment as shown in
The exemplary identity assignment scheme described above with respect to
A useful property of both of the identity assignment schemes as described above with respect to the exemplary embodiments of
Since no state transfer is truly atomic, and since there will be a time interval before the new location of an identity is known by all of its users after it has been redistributed, an additional identity assignment feature can be provided. More specifically, according to exemplary embodiments, e.g., as an optional feature for either or both of the exemplary embodiments described above, each message can convey its calculated target identity. Hence, messages which are sent towards a certain component 30, 40 just after the corresponding identity was transferred to a different component 30, 40, but before the translation table 38, 48 on the sending component 30, 40 or client 34, 44 was updated, can be re-evaluated on the old target component 30, 40, and re-directed towards the new one. This will, for example, minimize traffic disturbances during a planned component addition/removal or a traffic rebalancing.
The exemplary embodiments described above, illustrate methods, devices, systems and software for handling assignment and redistribution of identities associated with components of a distributed application. Thus, some aspects of these exemplary embodiments can be implemented as software. Thus, the process or method steps associated with these exemplary techniques can be performed by one or more processors executing sequences of instructions (software) contained in a memory device. Such instructions may be read into the memory device from other computer-readable mediums such as secondary data storage device(s). Execution of the sequences of instructions contained in the memory device causes the processor to operate, for example, as described above. In alternative embodiments, hard-wire circuitry may be used in place of or in combination with software instructions to implement the present invention.
From a hardware perspective, the distributed application (including the software components 30, 40 and the clients 34, 44) may be running on one device, e.g., computer, server or the like, or on multiple devices. Scalable control planes are one example of a commercial product which may include these exemplary embodiments, but the present invention is by no means limited to implementation in scalable control planes but can be used in, for example, any distributed processing system including functional addressing of components. Although the particular hardware configuration on which identity assignment according to these exemplary embodiments is performed is arbitrary and implementation dependent,
The foregoing description of exemplary embodiments provides illustration and description, but it is not intended to be exhaustive or to limit the invention to the precise form disclosed. Modifications and variations are possible in light of the above teachings or may be acquired from practice of the invention. The following claims and their equivalents define the scope of the invention.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US6173313 *||Jun 24, 1998||Jan 9, 2001||Oracle Corporation||Methodology for hosting distributed objects at a predetermined node in a distributed system|
|US6915296 *||Oct 29, 2002||Jul 5, 2005||Agere Systems Inc.||Incremental reorganization for hash tables|
|US7054927 *||Jan 29, 2002||May 30, 2006||Adaptec, Inc.||File system metadata describing server directory information|
|US20060004791||Jun 21, 2004||Jan 5, 2006||Kleewein James C||Use of pseudo keys in node ID range based storage architecture|
|WO2001086427A2||May 9, 2001||Nov 15, 2001||Sun Microsystems, Inc.||Transformation of objects between a computer programming language and a data representation language|
|1||International Search Report from corresponding PCT Application No. PCT/IB2009/052124.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US8908521||Apr 4, 2012||Dec 9, 2014||Telefonaktiebolaget L M Ericsson (Publ)||Load balancing for stateful scale-out network services|
|US9044543||Jul 17, 2012||Jun 2, 2015||Elwha Llc||Unmanned device utilization methods and systems|
|US9061102||Aug 31, 2012||Jun 23, 2015||Elwha Llc||Unmanned device interaction methods and systems|
|US9254363||Aug 31, 2012||Feb 9, 2016||Elwha Llc||Unmanned device interaction methods and systems|
|US9713675||Aug 31, 2012||Jul 25, 2017||Elwha Llc||Unmanned device interaction methods and systems|
|WO2013150449A1||Apr 2, 2013||Oct 10, 2013||Telefonaktiebolaget Lm Ericsson (Publ)||Load balancing for stateful scale-0ut network services|
|U.S. Classification||709/245, 709/203, 709/217|
|Cooperative Classification||G06F9/5088, G06F2209/463|
|May 24, 2011||CC||Certificate of correction|
|Jul 25, 2014||FPAY||Fee payment|
Year of fee payment: 4