Object load balancing

• US 6,473,791 B1
• Filed: 08/17/1998
• Issued: 10/29/2002
• Est. Priority Date: 08/17/1998
• Status: Expired due to Term

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Gray, Jan S., Mital, Amit, Limprecht, Rodney, Al-Ghosein, Mohsen
• Primary Examiner(s): Banankhah, Majid
• Application Number:
  US09/135,106
• Time in Patent Office: 1,534 Days
• Field of Search: 709/100, 709/101-108, 709/310, 709/312, 709/315, 709/317, 709/320, 709/203, 709/223, 709/224, 709/217, 709/330
• US Class Current: 709/217
• CPC Class Codes: G06F 9/505 considering the load

Abstract

Intelligent Trust Management provides a centralized security facility that gives system components a flexible mechanism for implementing security policies. System components such as applications create a request describing an action that needs to be checked against an appropriate security policy. The request is given to a trust system that determines which policy object applies to the request, and may pass request arguments to the policy. The policy objects include executable code that uses any arguments along with dynamically obtained variable information to make a decision. The decision is returned to the system component, which then operates accordingly. Policy objects may maintain state and interface with the user independent of the system component in order to obtain information to make their decisions. Policy objects may call other policy objects and/or mathematically combine the results of other policy objects to make a decision.

Claims

1. A computer-implemented method for providing an architecture accommodating load balanced instantiation of software objects within a server group of a plurality of server computers, the architecture being transparent to the objects, the method comprising the steps:

interposing a wrapper between a first load balanced object instantiated at a host server computer of the server group and a client of the first load balanced object, the wrapper intercepting calls to the first load balanced object to generate a performance measurement at the host server computer transparently to the first load balanced object;

at a router computer, monitoring performance at the server computers in the server group by collecting the performance measurement from the host server computer and at least one other performance measurement from other server computers in the server group to ascertain measured performance at the servers; and

when measured performance of the host server is preferred over measured performance of other server computers in the server group, instantiating a second load balanced object on the host server computer as a result of the performance measurement.

2. A computer-readable medium having computer-executable instructions for performing the steps of claim 1.

3. The method of claim 1 wherein

the first object is of an object class;

the performance measurement is identified by object class as a measurement of performance for objects having the object class of the first object;

the monitoring step determines performance at server computers in the server group for objects having the object class of the first object; and

the instantiating step instantiates the second object at the host server computer based on whether the second object has an object class matching the object class of the first object.

4. The method of claim 1 wherein a plurality of objects of a same specified object class are instantiated on a selected target group associated with the object class, the target group being a subset of the server group of server computers.

5. The method of claim 1 wherein a selected replaceable load balancing engine designated for an object class determines when monitored performance of the host server computer is preferred over monitored performance of other server computers in the server group.

6. The method of claim 1 wherein the monitoring step comprises periodically blending the performance measurement with plural other similar performance measurements from the host server computer to generate a performance value indicative of performance at the host server computer, the blending sufficiently delayed by a time interval to dampen variance in the performance value.

7. The method of claim 6 wherein the time interval is selected by a system administrator.

8. The method of claim 1 wherein the performance measurement is generated transparently to the first object by a server-side policy of the first object, wherein the policy is invoked by the wrapper.

9. The method of claim 8 wherein

the server-side policy is shared by a third object at the server computer;

and

the server-side policy generates an additional performance measurement associated with the third object, wherein the additional performance measurement is collected by the router computer to monitor host server computer performance.

10. The method of claim 8 wherein the performance measurement indicates method response time at the host server computer as generated by the server-side policy of the first object, the policy operative to observe a first time as a result of an enter event sent to the policy before a method call to the object, the policy further operative to observe a second time as a result of a leave event sent to the policy after the method call to the object, the policy further operative to generate the performance measurement by subtracting the first time from the second time.

11. The method of claim 8 wherein the performance measurement indicates database load as observed at the host server computer transparently to the first object by code invoked by the wrapper.

12. The method of claim 8 wherein the performance measurement indicates database access latency as observed at the host server computer transparently to the first object by code invoked by the wrapper.

13. In a computer network, a load balancing service for distributing object related resource requests among a plurality of load bearing targets identified by target identifiers, the load balancing service comprising:

a routing table mapping object class identifiers to target identifiers, at least one of the mapped object class identifiers mapped to a target identifier identifying a target exhibiting a favorable processing metric for processing objects having an object class of the mapped object class identifier; and

a system service for receiving an object related resource request comprising a supplied object class identifier matching an object class identifier in the table, the system service operative to route the resource request to the target identified by the target identifier mapped to by the supplied class identifier in the routing table.

14. The service of claim 13 wherein the system service is an operating system service.

15. The service of claim 13 wherein the target identifiers in the routing table identify server computers in the computer network.

16. The service of claim 13 wherein target identifiers in the routing table identify threads at server computers in the computer network.

17. The service of claim 13 wherein the target identifiers in the routing table identify processes at server computers in the computer network.

18. The load balancing service of claim 13 further comprising:

a collective metric data store operative to receive performance values indicative of the targets'"'"' performance according to a processing metric; and

a load balancing engine operative to dynamically adjust mappings in the routing table to map an object class identifier to a target identifier identifying a target having a more favorable performance value in the collective metric data store according to the processing metric.

19. The load balancing service of claim 18 wherein the collective metric data store comprises a dampened performance value indicative of a plurality of blended received performance values, at least certain of the blended received performance values of sufficient age to dampen variance in the dampened performance value in the collective metric data store;

and

the load balancing engine consults the dampened performance value to dynamically adjust mappings in the routing table.

20. In a router computer, a load balancing service for distributing an object creation request comprising an object creation request characteristic among a target group comprising a plurality of server computers, the load balancing service comprising:

a host server computer selection means for selecting a host server computer to host the object creation request, the host server computer selection means operative to accept a supplied object creation request characteristic and specify a selected host server computer, the specified host server computer selected by the host server computer selection means from the target group based on the specified object creation request characteristic;

a system service for routing the component creation request to a server computer in the target group, the system service operative to accept the component creation request comprising the object creation request characteristic, supply the object creation request characteristic to the host server computer selection means, accept from the host server computer selection means a specified selected host server computer and route the object creation request thereto.

21. The load balancing service of claim 20 wherein the object creation request characteristic of the object creation request is a class identifier, and the host server computer selection means specifies a server computer having an activated instantiated object of the class identifier.

22. The load balancing service of claim 20 wherein the object creation request characteristic of the object creation request is a client identity identifying a client computer, and the host server computer selection means specifies a server computer to which object creation requests for the client computer have previously been routed based on the previously-routed requests.

23. The load balancing service of claim 20 wherein the object creation request characteristic is selected from the group consisting of a class identifier of the object creation request, a client computer identity of a computer issuing the object creation request, and a process identity of a process issuing the object creation request.

24. The load balancing service of claim 20 wherein the object creation request is generated by a process executing in an execution environment with associated environment data defining the execution environment, and the object creation request characteristic of the object creation request is the execution environment data.

25. The load balancing service of claim 20 wherein the target group is dynamically adjustable to add or remove a specified server computer from the group based on instructions provided by the specified server computer to the router computer.

26. The load balancing service of claim 20 wherein the object creation request characteristic of the object creation request is a class identifier, the load balancing service further comprising:

a global routing table mapping object class identifiers to host server computers in the target group,

wherein the host server computer selection means consists of a mapping function on the global routing table.

27. The load balancing service of claim 26 wherein the global routing table is dynamically updated with processing metric data retrieved from the server computers in the target group.

28. The load balancing service of claim 27 wherein the processing metric data is generated by a RPC layer between the router computer and the server computers.

29. In a computer network, an object creation architecture for balancing a load of object creation requests among a plurality of server computers, the architecture comprising:

a routing table comprising a plurality of stored object class identifiers, wherein at least one stored object class identifier is associated with a server computer;

at a router computer, a load balancing service responsive to a supplied object class identifier in an object creation request from a client program on a client computer and operative to select a server associated with the supplied object class identifier in the routing table, the load balancing service further operative to route the object creation request to an object creation service at the selected server computer;

at the selected server computer, an object creation service responsive to the object creation request from the load balancing service and operative to create a server object of an object class associated with the supplied identifier and further operative to assemble a stub with the server object, the stub operative to monitor calls to the server object to observe and store in a metric data store at the selected server computer a performance value, the performance value indicative of performance at the selected server computer according to a processing metric;

at the router computer, a metric collector operative to retrieve the observed performance value from the metric data store and integrate the performance value into a collective metric data store, wherein the collective metric data store comprises metric data from plural server computers; and

a load balancing engine at the router computer operative to consult the collective metric data store and associate in the routing table an object class identifier with a server having a performance value determined superior according to the processing metric by the load balancing engine.

30. The architecture of claim 29 wherein the load balancing engine is a first load balancing engine operative to associate a first class identifier with a server, the architecture further comprising:

a second load balancing engine operative to consult the collective metric data store and associate in the routing table a second class identifier with a server having a performance value determined superior according to the processing metric by the second load balancing engine.

31. In a computer network comprising a router computer, a plurality of server computers and a plurality of client computers, an architecture for balancing a load of computer object processing among the server computers, the architecture comprising:

a routing table at the router computer associating object classes with server computers;

a monitor at a server computer, the monitor operative to intercept a reference to an instantiated first software object of a monitored object class to transparently conduct and record a processing metric observation, the monitor further operative to send a processing metric value based on the processing metric observation and indicative of performance at the server computer;

a load balancing service at the router computer, the load balancing service operative to receive a client computer request to create a second object of the monitored object class and route the request to a selected server associated with the monitored object class in the routing table, the load balancing service responsive to the processing metric value sent by the monitor to associate a server having a favorable processing metric value with the monitored object class in the routing table; and

an object creation service at the selected server operative to receive the request from the load balancing service and create an object of the monitored object class.

32. The architecture of claim 31 wherein the load balancing service comprises a plurality of load balancing engines, each load balancing engine operative to modify associations in the routing table relating to an object class particular to the load balancing engine.

33. The architecture of claim 31 wherein the monitor comprises a plurality of metric trackers, each metric tracker operative to conduct and record a performance metric observation relating to an object class particular to the metric tracker.

34. In a computer network having a router computer and a plurality of server computers in a target group, a method for balancing object processing among the plurality of server computers, the method comprising:

conducting plural processing performance metric observations associated with a software object class at a server computer;

periodically blending the observations into a representative value indicative of performance at the server computer;

periodically transferring the representative value from the server computer to a router computer to provide plural successive representative values to the router computer, wherein transferring is sufficiently delayed to facilitate blending a number of observations to dampen variance in the successive representative values;

receiving at a router computer the plural representative values from the server computer and plural representative values from at least one other server computer in the target group; and

routing resource requests received by the router computer to a server computer in the target group having a representative value indicative of more favorable performance than another server computer in the target group.

35. The method of claim 34 wherein the blending step comprises calculating the average of plural response times observed at the server computer.

36. In a computer network comprising a client computer and a server computer, a computer implemented method for accommodating object transparent rebalance messages from the server computer to the client computer, the method comprising:

generating a proxy at the client computer for receiving and forwarding calls from a client program to a software object;

generating a stub at the server computer for receiving and forwarding calls from the proxy to the software object;

establishing a connection between the proxy and the stub;

providing the proxy with rebalance message receptive code run by the proxy transparently to the server object and the client program;

providing the stub with rebalance message generating code run by the stub transparently to the server object and the client program;

when the stub is referenced, determining in the rebalance message generating code whether performance at the server computer is below an acceptable minimum; and

if performance at the server computer is below the acceptable minimum, sending a rebalance message from the rebalance message generating code to the rebalance message receptive code.

37. The method of claim 36 wherein the software object is a first software object, the method further comprising:

upon receiving a rebalance message in the rebalance receptive code, severing the connection between the proxy and the stub and creating a second software object on a computer other than the server computer.

38. A load balancing service for balancing object processing among a plurality of server computers by accommodating object creation requests from a plurality of client programs executing on a plurality of client computers, the load balancing service comprising:

at a client computer, a configuration database for associating object classes with remote computers, at least one object class in the configuration database associated with a router computer;

at the client computer, an operating system service operative to receive an object creation request comprising an object class, the operating system service further operative to direct the object creation request to a computer associated with the object class in the configuration database;

at the router computer, a routing table for associating an object class with a server computer;

at the router computer, a routing service operative to receive the object creation request from the client computer and route the request to a selected server computer associated with the request'"'"'s object class in the routing table;

at the selected server computer, a class instance creator operative to receive the object creation request and create an object of the request'"'"'s object class;

an operating system service for providing a wrapper around the object, the wrapper comprising a method invocation service, the method invocation service operative to receive invocations of a method of the object from a client program and forward the invocation to the object, the method invocation service further operative to observe execution of the method by the object to produce an object class method performance observation, the object class method performance observation associated with the object class of the object and indicative of the method'"'"'s performance according to a processing metric;

an observation collection service at the router computer operative to collect and store the object class method performance observation and at least one other object class method performance observation in a collective observation store from a target group, the target group comprising the selected server computer and other plural server computers; and

a load balancing engine at the router computer operative to evaluate the object class method performance observations from the target group to associate a favorable server computer in the target group with a selected object class in the routing table, the evaluated observations associated with the selected object class in the collective observation store, the favorable server computer having a more favorable object class method performance observation than another server in the target group according to the processing metric.

39. The computer-readable medium of claim 38 wherein the processing metric is response time for a method of an object of the object class indicated by the selected identifier indicative of an object class, and the data structure is sharable among a plurality of load balancing engines at the router computer and an activator at the router computer.

40. A computer-readable medium having stored thereon a data structure for routing object creation requests from a remote client computer, the data structure comprising:

identifiers indicative of an object class; and

a server identifier associated in the data structure with a selected one of the identifiers indicative of an object class, the server identifier indicative of a server computer providing to a router computer favorable processor metric observations for processing objects of the object class indicated by the selected one of the identifiers indicative of an object class;

wherein the data structure is an accelerated routing table comprising a lookup table associating a server identifier with a hash function of an identifier indicative of an object class.