(12) United States Patent
`Wallis et al.
`
`US006282569B1
`(10) Patent N0.:
`US 6,282,569 B1
`(45) Date of Patent:
`Aug. 28, 2001
`
`(54) NAME SERVER COMPUTER HAVING A
`LOAD LEVELLING FACILITY TO SPREAD
`THE LOAD FROM CLIENT COMPUTERS
`ACROSS A PLURALITY OF SERVER
`COMPUTERS
`
`_
`(75) Inventors: Graham Derek Wallis, Locks Heath;
`Michael George Tayl0r> Southampton;
`Mlchael Platt> Hambledon; AI_1dreW
`James Stanford-Clark, Eastleigh, all of
`(GB)
`(73) Assignee: International Business Machines
`Corp” Armonk, NY (Us)
`
`( * ) Notice:
`
`SubJect to any disclaimer, the term of this
`patent is extended or adJusted under 35
`U-S~C~ 154(9) by 0 days-
`
`(21) Appl. No.: 08/868,111
`(22) Filed
`Jun 3 1997
`'
`'
`’
`Related US Application Data
`
`(63) Continuation of application No. 08/297,469, ?led on Aug.
`29, 1994, now abandoned.
`Foreign Application Priority Data
`(30)
`Sep. 11, 1993
`(GB) ................................................ .. 9318877
`(51) Int. Cl.7 .................................................... .. G06F 12/00
`_
`_
`_
`(52) US. Cl. ........................ .. 709/224, 709/203, 709/223,
`_
`_
`709/226’ 709/205
`(58) Fleld of Search ................................... .. 709/201, 202,
`709/203> 204> 217> 218> 219> 226> 227>
`228> 330; 700/178; 710/100; 707/202> 203>
`204> 205
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`4/1988 Frauenthal et a1. ................ .. 379/221
`4,737,983
`5,155,851 * 10/1992 Krishnan ......... ..
`395/650
`5,249,290 * 9/1993 HeiZer ................................ .. 395/650
`
`FOREIGN PATENT DOCUMENTS
`
`Egg '
`'
`OTHER PUBLICATIONS
`Gopal et al, Analysis of a Class of Distributed Directory
`Algorithms, lnfocom :89, pp 293_302_*
`Spahni et al, A Local Name Server for Organizational
`Message Handling Systems, Digital Communications 1988
`Zurich Seminar pp 239_246_4
`Anklesaria et al, The Internet Gopher Protocol, Network
`Workmg Group’ Mar' 1993'
`Primary Examiner—Majid Banankhah
`(74) Attorney, Agent, or Firm—Jerry W. Herndon
`(57)
`ABSTRACT
`
`*
`
`'
`
`A name server computer and method of operating such a
`computer, for facilitating a connection of a program on a
`client computer to a server, the server consisting of a
`plurality of server computers With shared resources. The
`name server computer, the client computer, and the server
`computers all reside in a logical network. The name server
`computer receives a request from the client computer for a
`Computer address of a Server Computer identi?ed by a Server
`computer name sent With the request, such computer address
`enabling a connection to be made from the client computer
`to that server computer via the netWork. A list of server
`computer names With their computer addresses is provided.
`The name Server Computer uses the hist to Convert th? Server
`computer name received from the client computer into the
`Com uter address Ofthe Server Com uter, and then Sends the
`P
`P
`computer address to the client computer. The computer
`further includes decision logic for Studying the Server Com_
`puters at predetermined intervals having regard to a prede
`termined test criteria, to select one of the server computers.
`The list is then updated by associating the computer address
`for the server computer selected by the decision logic With
`a particular server computer name contained as a generic
`server computer name in the list. Using this technique, When
`1'
`t
`1
`'fl
`th
`'
`1
`a C 16“, compu erthspecl es t e déenenc fsgver Compu er
`nameicli @513? :1 83mm er i‘
`F655 0
`6 Server Com‘
`Puter 1 en“ 6
`Y t 6 661510“ Ogle
`
`(List continued on next page.)
`
`13 Claims, 3 Drawing Sheets
`
`2a\
`
`GENERIC NAME
`
`30
`
`
`
`
`
`CLIENTE - _ — v T _ _ _ — _ — COMPUTER '1
`
`J0 1”
`
`NVERSION
`
`MEMORY \ma
`
`.
`1
`1
`.
`.
`.
`I
`.
`.
`.
`1
`I
`.
`
`.
`
`:
`:
`'
`l
`
`1
`i
`.
`.
`.
`
`I
`.
`4
`.
`
`110
`
`170 MESSAGING
`MEANS
`
`STORAGE
`DEVICE
`
`8a
`
`WRITING
`DECISION LOGIC
`12”
`MEANS
`13,, --- ,5,
`a
`15
`
`. 14a .
`l
`l
`------ - -
`.
`
`.
`.
`
`40
`
`I
`
`so
`
`'
`
`sa
`
`‘
`
`.
`
`SERVER
`COMPUTER 1
`
`SERVER
`COMPUTER 2
`
`SERVER
`COMPUTER a
`
`.
`
`Petitioner Microsoft Corporation - Ex. 1016, p.1
`
`

`
`US 6,282,569 B1
`Page 2
`
`US. PATENT DOCUMENTS
`
`5,335,356 * 8/1994 Andersson ........................ .. 455/54.1
`5,341,477 * 8/1994 Pitkin et a1.
`395/200
`5,408,619 * 4/1995 Oran ................................... .. 395/325
`
`5,434,914 * 7/1995 Fraser ................................. .. 379/219
`5,475,819 * 12/1995 Miller et a1. .
`. 395/200.03
`575047894 * 4/1996 Ferguson et aL ________________ " 395/650
`
`* cited by examiner
`
`Petitioner Microsoft Corporation - Ex. 1016, p.2
`
`

`
`U.S. Patent
`
`Aug. 28,2001
`
`Sheet 1 of3
`
`US 6,282,569 B1
`
`Q5
`
`Petitioner Microsoft Corporation - Ex. 1016, p.3
`
`

`
`U.S. Patent
`
`Aug. 28, 2001
`
`Sheet 2 of3
`
`US 6,282,569 B1
`
`N.03
`
`§§N
`
`ZO_._.<w_._<_._._Z_
`
`
`
`
`
`oz_m._.wo_Em_s_ozmw
`
`
`
`
`
`oz_Emo_Em_s_ozmm
`
`
`z%_Sn_s_oomm_>EmO._.
`
`mmmsmzooEimmOp
`
`Nmm_5n_s_oom_m>mm_mOH
`
`
`oz_Emo_Em__>_ozmm
`
`—m_m_.5n_s_OoEfimm9oz_Em
`
`o_Em__2Qzmw
`
`
`
`
`
`mm_>mmmm_s_<zO._.mo<mwm_s_ozmw
`
`
`
`§a.Nm_o<mO._.wm:.<n_nS
`
`
`
`mmSn_s_oomm_>mmm
`
`§kN
`
`3....
`
`>mosm_s_u_Om:<on_:mo“.
`
`
`
`n_o_m_m_n_omz__>_mm_Eom_mn_
`
`
`
`n_O>m_n_xm4:2:._._<>>
`
`QQN
`
`
`
`
`
`imamB<m._..mz__>_mm_m_o§®N
`
`
`
`
`
`wmm.S%,_oomm_>mm_ws_oE
`
`
`
`wmmzonammm._.<._._Oo§hN
`
`§hN
`
`Petitioner Microsoft Corporation - Ex. 1016, p.4
`
`Petitioner Microsoft Corporation - Ex. 1016, p.4
`
`
`
`
`
`
`
`
`
`

`
`U.S. Patent
`
`Aug. 28,2001
`
`Sheet 3 of3
`
`US 6,282,569 B1
`
`/430
`SERVER CLUSTER
`I ____________________________ ' ‘I
`
`410
`
`:
`:
`I
`I
`:
`I
`I
`I
`I
`I
`:
`:
`
`:
`;
`;
`:
`g
`:
`;
`;
`;
`;
`
`I -------- - - K5?”
`SERVER
`:
`COMPUTER I
`
`40
`
`I
`SERVER
`COMPUTER I
`I
`I
`SERVER
`COMPUTER I
`' 400
`I
`SERVER
`COMPUTER I
`
`. """"""" ' ‘
`
`SERVER
`COMPUTER
`
`SERVER
`COMPUTER
`
`SERVER
`COMPUTER
`
`SERVER
`COMPUTER
`
`:
`1
`I
`I
`:
`I
`;
`I
`:
`I
`:
`:
`
`I
`
`Petitioner Microsoft Corporation - Ex. 1016, p.5
`
`

`
`US 6,282,569 B1
`
`1
`NAME SERVER COMPUTER HAVING A
`LOAD LEVELLING FACILITY TO SPREAD
`THE LOAD FROM CLIENT COMPUTERS
`ACROSS A PLURALITY OF SERVER
`COMPUTERS
`
`The application is a continuation, of application Ser. No.
`08/297,469, ?led Aug. 29, 1994, noW abandoned.
`The present invention relates to a data processing system
`for facilitating the connection of a program on a client
`computer to a server, the server consisting of a plurality of
`server computers With shared resources.
`The data processing system, the client computer, and the
`server computers are all resident on a netWork. This netWork
`need not be one physical netWork such as a Local Area
`NetWork (LAN); for instance it may consist of a number of
`LANS or WANS (Wide area networks) connected together
`(eg. via ‘bridges’) to form a single logical netWork. HoWever
`the same netWork protocol Will be employed throughout the
`netWork, a typical eXample of such a protocol being TCP/IP
`Which Will be familiar to those skilled in the art.
`In many environments it is increasingly found that a
`number of server computers are connected together using
`some form of netWork, eg. a LAN. It is often the case that
`several users of client computers Will be connected to one
`such server computer, Whilst other server computers stand
`idle. An eXample of this is When such computers are situated
`in Workers’ of?ces, connected by, for example, a token ring
`LAN using the standard TCP/IP netWork protocol. When
`Workers are aWay from their of?ces, their computers Will
`usually stand idle.
`In such situations it is commonly the case that a feW of
`the computers in the netWork are heavily loaded, Whilst
`other computers in the netWork are very lightly loaded,
`giving poor response and performance for the client com
`puters using the heavily loaded server computers. Hence
`there is a problem of hoW to enable the client user load to be
`spread more evenly across the available computing
`resources of the server in a manner Which is transparent to
`the client computer and its programs. If transparency is to be
`achieved, standard protocols need to be observed in order
`that client computers can use a variety of connection meth
`ods Without modi?cation of any programs being required.
`A prior art technique Which has been developed to
`provide some sort of load spreading is called “Static load
`levelling”. With this technique each application on each
`client computer has a designated server to Which it alWays
`connects. Hence, for example, if there are 200 potential
`clients of a server having ?ve server computers, a pre
`speci?ed group of, say, 40 of the clients Will be told (or
`con?gured) to alWays connect to machine 1, etc. On average
`it may be argued that this Will give a reasonably even load
`across all of the server computers. HoWever in practice it is
`often the case that, using this technique, a large number of
`users of client computers are connected to one server
`computer, While an adjacent server computer stands com
`pletely idle (eg. given the above eXample there could easily
`be 40 users on one server computer Whilst the other 4 server
`computers stand idle). Hence in situations Where the user
`loading changes from time to time, the prior art static load
`levelling technique is not particularly satisfactory. What is
`required in such instances is a more ‘dynamic’ technique
`Which can respond to changing user loads, and thus direct
`neW users to the most suitable (eg. least heavily loaded)
`server computers in the server.
`Other prior art techniques can be found in other
`environments, such as those Where job allocation is an issue.
`
`10
`
`15
`
`25
`
`35
`
`45
`
`55
`
`65
`
`2
`For instance in “batch processing”, a client computer sub
`mits an encapsulated task to a central server, Which deter
`mines Which one of several possible servers is quiet enough
`to be able to handle the task. The task is sent to that server,
`is processed, and the results are then sent back to the client
`(eg. as a results ?le, or by electronic mail). With a batch
`processing system, there is a brief connection to the central
`server While the job is transferred from the client to the
`server allocated by the central server. After this brief con
`nection the client disconnects, and has no more interaction
`With the submitted task until it has been completed, and the
`results have been passed back to the client by some means.
`HoWever in the situation With Which We are currently
`concerned, the dynamic load levelling technique that is
`required must be able to deal With “interactive” sessions.
`Rather like a phone conversation, the connection betWeen
`the program on the client computer and a particular server
`computer Will persist for the duration of the “conversation”
`session. Hence the batch processing concept is inappropriate
`in the present situation.
`It is possible to Write some speci?c code Within a
`program on a client computer Which contains internal
`message-passing systems to route Work from that client
`program to a corresponding server program. Such systems
`are dedicated only to that particular client program, and the
`connection and load-levelling methods are not accessible to
`other client-server applications. Often, such systems operate
`by the client connecting to a speci?c “host” server computer,
`and from there the Work Will be sent to another server for
`processing. Clearly this technique can result in large bottle
`necks arising at the “host” server computer.
`Hence such a technique is not suitable in the present
`situation since it only supports one very speci?c type of
`client-server connection, Whereas We need a technique that
`Will alloW any client-server connection method using the
`netWork protocol to be connected to a quiet server in a Way
`that is completely transparent to the client program. Further
`the above technique relies on an initial connection to the
`‘central’ host server computer, Which then passes the request
`on to another server computer; as described above this can
`potentially create a serious bottleneck.
`It is an object of the present invention to provide a
`technique Which facilitates a connection betWeen a client
`program and a server computer on a server in a Way that
`takes into account the current status of the server computers
`forming the server. This technique must observe standard
`netWork protocols and should operate in a manner Which is
`transparent to the client program requesting access.
`Accordingly the present invention provides a data pro
`cessing system for facilitating a connection of a program on
`a client computer to a server, the server consisting of a
`plurality of server computers With shared resources, the data
`processing system, the client computer, and the server
`computers residing in a netWork, the system comprising:
`input means for receiving a request from the client computer
`for a machine address of a server computer identi?ed by a
`server computer name sent With the request, such a machine
`address enabling a connection to be made from the client
`computer to that server computer via the netWork; a storage
`device for storing a list identifying server computer names
`With machine addresses of the server computers; conversion
`means for using the list to convert the server computer name
`received by the input means into the machine address of the
`server computer; output means for sending the machine
`address from the conversion means to the client computer;
`the system being characterised by: decision logic for study
`ing the server computers at predetermined intervals having
`
`Petitioner Microsoft Corporation - Ex. 1016, p.6
`
`

`
`US 6,282,569 B1
`
`3
`regard to predetermined test criteria, in order to select one of
`the server computers; and Writing means for updating the list
`by associating the machine address for the server computer
`selected by the decision logic With a particular server
`computer name contained as a generic server computer
`name in the list; Whereby When a client computer speci?es
`the generic server computer name, it receives the machine
`address of the server computer identi?ed by the decision
`logic.
`Typically the conversion means Will access the list from
`a local piece of storage, the data processing system having
`a copier to copy the list from the storage device to that piece
`of memory. In preferred embodiments the data processing
`system further comprises a messaging means, responsive to
`the updating of the list by the Writing means, for sending a
`message to the copier requesting the copier to copy the
`updated list into the piece of local memory.
`Any manner of predetermined test criteria can be used in
`the data processing system of the invention, for eXample the
`amount of idle processor time, the number of processes
`running, the amount of free memory, the “load average”, etc.
`HoWever in preferred embodiments the predetermined test
`criteria are such that the decision logic identi?es the server
`computer having the least number of client programs logged
`on to it.
`In preferred embodiments the predetermined intervals
`are variable and Will either be set by a user of the system, eg.
`the system administrator, or Will be adjusted dynamically.
`The user Will also set the predetermined test criteria to be
`used by the decision logic.
`Further in preferred embodiments the user can limit the
`number of server computers Which the decision logic stud
`ies. This may be useful if, for instance, some of the server
`computers have not got access to all of the resources that
`other server computers have access to, and so Would not be
`suitable as server computers to be associated With the
`generic server computer name.
`In some embodiments it may be advantageous to use a
`plurality of generic names. Each server name Would then
`have a number of server computers Whose machine
`addresses are associated With that generic name, the decision
`logic employing different sets of predetermined test criteria
`for each generic name. In such embodiments one or more of
`the server computers can be associated With a plurality of the
`generic names.
`VieWed from a second aspect the present invention
`provides a method of operating a data processing system to
`facilitate a connection of a program on a client computer to
`a server, the server consisting of a plurality of server
`computers With shared resources, the data processing
`system, the client computer, and the server computers resid
`ing in a netWork, the method comprising the steps of: (a)
`receiving a request from the client computer for a machine
`address of a server computer identi?ed by a server computer
`name sent With the request, such a machine address enabling
`a connection to be made from the client computer to that
`server computer via the netWork; (b) storing a list identify
`ing server computer names With machine addresses of the
`server computers in a storage device; (c) converting, With
`reference to the list, the server computer name received at
`step (a) into the machine address of the server computer; (d)
`sending the machine address identi?ed at step (c) to the
`client computer; the method being characterised by the steps
`of: (e) employing decision logic to study the server com
`puters at predetermined intervals having regard to predeter
`mined test criteria, in order to select one of the server
`computers; and
`updating the list by associating the
`
`10
`
`15
`
`25
`
`35
`
`45
`
`55
`
`65
`
`4
`machine address for the server computer selected by the
`decision logic With a particular server computer name con
`tained as a generic server computer name in the list; Whereby
`When a client computer speci?es the generic server com
`puter name at step (a), it receives the machine address of the
`server computer identi?ed by the decision logic.
`The present invention Will be described further, by Way
`of eXample only, With reference to an embodiment thereof as
`illustrated in the accompanying draWings, in Which:
`FIG. 1 is a block diagram illustrating the data processing
`system of the preferred embodiment;
`FIG. 2 is a How diagram illustrating hoW the decision
`logic in the data processing system of the preferred embodi
`ment operates; and
`FIG. 3 illustrates a particular embodiment Where tWo
`generic computer names are used.
`in the preferred embodiment We Will consider the situ
`ation Where the server in question is a high performance
`database server Which has its data distributed across a
`netWork of server computers, this server netWork hereafter
`being referred to as a cluster. Database applications being
`run by users on client computers are required to connect to
`one of the server computers in the cluster to enable them to
`access the data in the database server. By the nature of the
`database system, it does not matter Which server computer
`the client connects to—all of the data is accessible from any
`server computer in the cluster. In the preferred embodiment
`the server computers and the client computers are all inter
`connected using TCP/IP on a token ring Local Area Net
`Work.
`For a large number of users, it is highly desirable to have
`a number of users on each of the server computers in the
`server cluster, rather than all users connecting to (and hence
`overloading) just one or a feW of the server computers. With
`a Widely varying user Workload pro?le for the database
`server, this problem can only be solved by providing some
`form of “load levelling” process, Which Will allocate neW
`client application instances to server computers in the cluster
`that are most suitable for the client connection (eg. because
`they are more lightly loaded than other server computers).
`Clearly this process must be dynamic, able to respond to
`changing load conditions over time. Since the database
`applications on the client computers are typically complex
`and often are supplied only in object code form, it Would be
`very dif?cult (or impossible) for the system administrator to
`alter them, and so it is essential that this allocation is done
`in a manner Which is entirely transparent to the client
`application.
`The manner in Which the data processing system of the
`preferred embodiment solves the above problems Will noW
`be described With reference to FIG. 1.
`Each client computer in a netWork using the TCP/IP
`protocol (there Will typically be many such client
`computers) Will have been informed by the netWork admin
`istrator that it is to communicate With a particular computer
`When it Wishes to convert a computer name of another
`computer in the netWork into a machine address. When
`utilising the present invention that computer Will be the data
`processing system Of the preferred embodiment.
`Hence When a program running on a client computer 20
`(for clarity, only one client computer is illustrated) Wishes to
`obtain access to a server computer (40, 50, 60) in the cluster
`it Will communicate With the data processing system 10 in
`order to obtain a full Internet machine address for the desired
`server (Internet addressing is part of the TCP/IP protocol).
`With the prior art technique the client computer Would
`specify a server computer name in this communication that
`
`Petitioner Microsoft Corporation - Ex. 1016, p.7
`
`

`
`US 6,282,569 B1
`
`5
`Was speci?c to one particular server computer in the cluster.
`The input means 30 of the data processing system 10 Would
`receive this server computer name and pass it to the con
`version means 70.
`In a storage device 80 of the data processing system a list
`is maintained Which identi?es server computer names With
`particular Internet addresses. When the conversion means is
`initiated the copier 90 copies this list from the storage device
`80 into a piece of local memory 100 accessible by the
`conversion means 70. Hence the conversion means Will
`access the list in memory 100 to ?nd the Internet address of
`the computer associated With the server computer name
`passed to it by the input means 30. This Internet address Will
`then be provided by the conversion means to the output
`means 110 for transmission back to the client computer 20.
`Once the client computer has the Internet address it can
`then make direct contact With the server computer residing
`at the Internet address provided; in FIG. 1 this is server
`computer 2. Since the TCP/IP protocol is used any of the
`access methods that use this protocol can be used to access
`the server computer.
`When using the data processing system of the preferred
`embodiment the program running on the client computer 20
`Will not use the server computer name that it previously
`used. Instead a generic server computer name Will be used.
`This generic server name Will either have been placed in the
`program’s con?guration ?le, or alternatively the user of the
`program Will specify the generic name When running the
`program.
`Within the data processing system, decision logic 120 is
`provided Which periodically studies the server computers in
`the cluster having regard to some predetermined test criteria,
`hereafter called the metric string. In the preferred embodi
`ment the metric string is a list of questions Which When
`ansWered by the various server computers Will enable the
`decision logic to decide Which server computer is most
`suitable for a client connection (the most suitable perhaps
`being the least heavily leaded server computer). The metric
`string can be altered as the system administrator deems
`appropriate, depending on What criteria the administrator
`Wishes to be used to select a server computer.
`In the preferred embodiment the decision logic actually
`sets up a number of child processes, each one being respon
`sible for sending the metric string to a particular server
`computer and receiving the response from the server com
`puter.
`Once the responses have been received the decision logic
`Will collate the responses, decide Which server computer is
`most suitable, and then request the Writing means 160 to
`pass the Internet address of that server computer to the
`storage device for association With the generic server com
`puter name. If hoWever the most suitable server computer is
`the same server computer as that identi?ed in the last
`iteration of the process then there is no need to update the
`storage device and the Writing means Will not be activated.
`Once any necessary update to the storage device 80 has
`been made the messaging means 170 Will notify the copier
`90 so that the copier updates the local memory 100 With the
`neW list as stored in the storage device 80.
`Hence When the client computer requests a machine
`address for the generic server computer name the conversion
`means 70 accesses the list in memory 100 and identi?es a
`machine address just as it Would if any other server com
`puter name had been given. HoWever in this instance the
`machine address actually relates to the server computer in
`the cluster Which has been identi?ed by the decision logic as
`the most suitable (eg. least heavily loaded). When this
`
`10
`
`15
`
`25
`
`35
`
`45
`
`55
`
`65
`
`6
`machine address is passed back to the client computer 20 via
`the output means 110, the client computer Will proceed to
`automatically access the server Which is most suitable.
`By this approach it Will be seen that a dynamic load
`levelling facility is provided Which is completely transparent
`to the client program. As far as the program is concerned it
`is requesting a machine address as normal and is using one
`of the normal TCP/IP access methods to gain access to the
`server computer allocated to it.
`In many of todays computing environments (eg Unix,
`AIX (Unix is a Trade Mark of Unix Systems Laboratories
`Inc)) an application is provided to perform the standard
`name resolution service (ie receipt of a computer name and
`conversion of that computer name into a full Internet
`address). This application is commonly knoWn as a
`“nameserver” application, and is installed on one or more
`computers in the logical netWork. Every other computer in
`the netWork is told to communicate With a speci?ed one of
`these ‘nameserver’ computers When it Wishes to determine
`an Internet address for any other computer in the netWork.
`Hence a nameserver computer provides a resolution service
`to client computers by receiving from them a convenient
`name (called a Uniform Resource Locator or URL) given to
`a particular computer (eg. abc.def.ghi.com), and converting
`it into a full Internet address (eg. 29.1.1966). This Internet
`address is then used by the routing subsystem (TCP/IP) to
`alloW a client user or application access to the physical
`computer (eg “abc” in this example).
`In the above example of a computer name, “abc” is the
`physical machine, “def” is typically the site location, “ghi”
`the organisation, and “com” one of the Internet classes (three
`such classes are (com)mercial, (edu)cation, (mil)itary).
`Domains and sub-domains can also be added as part of this
`computer name. Basically the name takes a hierarchical
`form, With the ?nest resolution at the beginning and the
`coarsest resolution at the end; this type of naming structure
`Will of course be Well knoWn to those skilled in the art.
`All TCP/IP-based applications, including remote-login,
`remote-shell, telnet, ftp, and also client-server applications
`(such as database applications), are aWare of the nameserver
`facility, and Will automatically go to the designated
`nameserver computer to ask for resolution of a computer
`name into an Internet address before attempting to make a
`connection to another computer in the netWork.
`If We consider FIG. 1 again, the standard nameserver
`facility Will include the folloWing elements: the input means
`30, the conversion means 70 With associated memory 100,
`the output means 110, the list stored in the storage device 80,
`and the copier 90.
`The nameserver application is a “daemon” (background)
`process Which runs on the data processing system; this data
`processing system may (but need not) be one of the server
`computers forming part of the cluster over Which users are
`to be distributed. In Unix-type operating systems (eg. AIX
`by IBM Corporation, Ultrix by Digital Equipment
`Corporation, OSF/1 by the Open SoftWare Foundation, and
`HP-UX by HeWlett Packard, etc) this daemon process is
`called “named” (name-daemon), and When it is initialised, it
`reads a special database ?le (named.data) stored on the
`storage device 80 to obtain details of the computer names
`about Which it is expected to knoW (over Which it has
`“authority”), and the corresponding Internet addresses
`(“dotted decimal”, e.g. 29.1.1966) for each computer name.
`Whilst the name daemon is operating, it can be forced to
`re-read the information from the named.data database ?le by
`the sending of an inter-process signal to the name daemon
`process telling it to update its internal tables 100 from the
`database ?le (named.data).
`
`Petitioner Microsoft Corporation - Ex. 1016, p.8
`
`

`
`US 6,282,569 B1
`
`10
`
`15
`
`7
`In the preferred embodiment of the present invention We
`provide a further facility Which runs on the same computer
`as the nameserver application (“named”), and interfaces
`With it. A ‘generic’ computer name is introduced into the
`database ?le (named.data), Which refers not to one speci?c
`computer, but to any one of a number of computers offering
`equivalent functionality. For example, the generic name
`might be “server.cluster.def.ghi.com”; a client program
`requesting a connection to ‘server cluster’ is requesting
`connection to any one of the computers in the server cluster.
`The further facility provided by the preferred embodi
`ment Will be referred to hereafter as the “User Load Lev
`eller” (ULL) application. This application is responsible for
`deciding Which server computer in the cluster is currently
`the least heavily loaded, according to some appropriate
`metric, and for conveying this information to the nameserver
`application. Then subsequent requests for resolution of the
`generic server computer name to an Internet address result
`in the nameserver application sending back to the client
`computer the Internet address of the server computer Which
`has been deemed to be the most appropriate server computer
`for connection at that point in time.
`The ULL application consists of the folloWing elements
`from FIG. 1: the decision logic 120 With child processes 130,
`140, 150; the Writing means 160; and the messaging means
`170. As described earlier With reference to FIG. 1 the ULL
`25
`application periodically (at a frequency Which can varied
`(eg. tuned by a system administrator or dynamically
`adjusted)) polls the server computers in the cluster to
`determine hoW “busy” in some sense they are. The metric
`used may vary, depending on the type of Work Which is
`being handled by the cluster, but may for eXample include
`the number of login sessions, number of application
`instances running, number of idle cpu cycles since the last
`poll, etc. The metric can be altered to ensure that it is
`appropriate to a speci?c situation.
`Based on the results of this polling, and taking into
`account the situation Where a server computer in the cluster
`is too busy to respond to the status request Within a certain
`number of seconds, the ULL application decides Which
`machine is currently the least heavily loaded. The ULL
`application then modi?es the database ?le (named.data) to
`associate the generic cluster machine name With the Internet
`address of this least heavily loaded machine, and sends the
`special inter-process signal via the messaging means 170
`Which tells the nameserver application to re-read its database
`?le. The nameserver application Will then, in response to a
`name resolution request from a client program, resolve the
`generic server computer name into the Internet address of
`the most appropriate server computer in the cluster for the
`client program to connect to.
`The process carried out by the decision logic 120 of the
`preferred embodiment Will noW be described in more detail
`With reference to FIG. 2. At step 200 the ULL application is
`initialised. Anumber of steps are carried out at initialisation.
`For eXample the application: checks for multiple copies of
`the ULL application in memory; cleans up from a previous
`run of the application (by freeing up system resources such
`as memory, locks and semaphores still held in the name of
`the previous instance of the ULL application); and locates
`the nameserver application (named) and its data ?le
`(named.data). The ULL application then parses its con?gu
`ration ?le to read information de?ned by the system
`administrator, such as the metric strings, poll periods, iden
`tities of server computers in the cluster, etc. Further the ULL
`application generates a num