I 1111111111111111 11111 1111111111 1111111111 11111 1111111111 1111111111 11111111
`US008499023B 1
`
`c12) United States Patent
`Harris
`
`(10) Patent No.:
`(45) Date of Patent:
`
`US 8,499,023 Bl
`Jul. 30, 2013
`
`(54) SERVLET-BASED GRID COMPUTING
`ENVIRONMENT USING GRID ENGINES AND
`SWITCHES TO MANAGE RESOURCES
`
`(75)
`
`Inventor: Lyle T. Harris, Portland, OR (US)
`
`(73) Assignee: Oracle America, Inc., Redwood City,
`CA (US)
`
`( *) Notice:
`
`Subject to any disclaimer, the term ofthis
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 2014 days.
`
`(21) Appl. No.: 11/087,420
`
`(22) Filed:
`
`Mar. 23, 2005
`
`(51)
`
`(2006.01)
`(2006.01)
`
`Int. Cl.
`G06F 15116
`G06F 151177
`(52) U.S. Cl.
`USPC ........................................... 709/201; 709/220
`( 58) Field of Classification Search
`USPC ................ 709/201, 238; 705/26, 30; 713/182
`See application file for complete search history.
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`5,838,916 A * 11/1998 Domenikos et al. .......... 709/219
`5,950,008 A *
`9/1999 van Hoff ....................... 717/139
`6,011,916 A *
`1/2000 Moore et al. .................. 717/104
`6,065,043 A *
`5/2000 Domenikos et al. .......... 709/203
`6,289,105 Bl*
`9/2001 Murota ......................... 380/286
`6,301,267 Bl* 10/2001 Ben-Ami ...................... 370/468
`6,356,937 Bl*
`3/2002 Montville et al.
`............ 709/206
`6,363,398 Bl*
`3/2002 Andersen .
`707/103 R
`6,643,708 Bl* 11/2003 Francis et al.
`................ 709/246
`6,732,101 Bl*
`5/2004 Cook .............................. 707/10
`6,760,752 Bl*
`7/2004 Liu et al. ....................... 709/206
`7,130,891 B2 * 10/2006 Bernardin et al.
`............ 709/218
`7,266,582 B2 *
`9/2007 Stelting ......................... 709/201
`7,293,059 B2 * 11/2007 Pearson ........................ 709/201
`
`8,135,841 B2 *
`.. ..... 709/226
`3/2012 Bozak et al.
`2002/0007453 Al*
`1/2002 Nemovicher ................. 713/155
`2002/0026487 Al *
`2/2002 Ogilvie et al.
`................ 709/206
`2002/0059144 Al*
`5/2002 Meffert et al. .................. 705/51
`2003/0046533 Al *
`3/2003 Olkin eta!. ................... 713/152
`2003/0196080 Al* 10/2003 Karman ........................ 713/150
`2004/0030893 Al *
`2/2004 Kararnchedu et al. ........ 713/168
`2004/0064824 Al *
`4/2004 McNeely et al.
`............. 719/316
`2004/0117661 Al*
`6/2004 Karaoguz et al. ............. 713/201
`2004/0139314 Al*
`7/2004 Cook et al. .................... 713/151
`2004/0143787 Al*
`7/2004 Grancharov et al.
`...... 715/501.1
`2004/0181469 Al*
`9/2004 Saeki .............................. 705/30
`2004/0199633 Al* 10/2004 Pearson ........................ 709/226
`2004/0215590 Al* 10/2004 Kroening .......................... 707 /l
`2005/0021594 Al*
`1/2005 Bernardin et al. ............ 709/200
`2005/0027785 Al
`212005 Bozak et al.
`2005/0027863 Al
`2/2005 Talwar et al.
`(Continued)
`
`WO
`
`FOREIGN PATENT DOCUMENTS
`* 9/1997
`WO 97/04194
`
`Primary Examiner - Guang Li
`(74) Attorney, Agent, or Firm - Marsh Fischmann &
`Breyfogle, LLP; Kent A. Lembke
`
`ABSTRACT
`(57)
`A method for providing a lightweight grid computing envi(cid:173)
`ronment. The method includes providing a web server run(cid:173)
`ning on a computer device and a grid engine on the web server
`that is adapted for processing grid compute requests from
`user programs. The grid engine receives a grid compute
`request from a user program that is processed by the grid
`engine to identify a client program available in the grid and a
`path in the grid to the client program. The method includes
`loading and running the client program with the grid engine to
`generate a client program output for transmittal to the user
`program. The grid compute request includes a URL request
`string including a name of the client program and the path to
`the client program and may also include a name of the com(cid:173)
`puter device hosting the web server and a path to the grid
`engine .
`
`10 Claims, 7 Drawing Sheets
`
`400~
`
`220
`
`222
`
`224
`
`226
`
`Netflix, Inc. - Ex. 1011, Page 000001
`IPR2022-00322 (Netflix, Inc. v. CA, Inc.)
`
`

`

`US 8,499,023 Bl
`Page 2
`
`U.S. PATENT DOCUMENTS
`2005/0044251 Al
`2/2005 Bozak et al.
`2005/0050183 Al
`3/2005 Hansen et al.
`2005/0060237 Al*
`3/2005 Barsness et al. ................ 705/26
`2005/0066056 Al*
`3/2005 Dominic ....................... 709/245
`2005/0080923 Al*
`4/2005 Elzur
`........ 709/238
`
`6/2005 Cho .............................. 709/201
`2005/0120073 Al*
`2005/0246547 Al* 11/2005 Oswald et al. ................ 713/182
`2006/0047850 Al * 3/2006 Singh Bhasin et al. ....... 709/238
`6/2006 Miloushev et al.
`........... 710/242
`2006/0143350 Al*
`
`* cited by examiner
`
`Netflix, Inc. - Ex. 1011, Page 000002
`
`

`

`0 ....
`N
`~o
`~
`:-'
`
`~
`
`2'
`
`~ = ~
`
`~
`~
`~
`
`00 .
`~
`
`,~~~Ill
`
`GRID PACKET
`UNPROCESSED
`
`138
`
`lv ·-:. -
`
`MEMORY
`
`137
`
`112
`
`ENGINE
`GRID
`
`WEB SERVER
`; PUBLIC DOMAIN
`~
`
`13Q
`GRID HOST SYSTEM
`
`I
`186
`
`/""130
`
`,..104
`
`µ-V
`ILJI
`
`PROGRAMS
`
`USER
`
`I
`
`USER DEVICE
`
`~~7i".1v164
`
`_L
`
`110
`
`,)
`
`r
`
`USER SYSTEM/SPACE
`
`'""
`
`100
`
`176
`
`174
`O
`
`1 I
`
`\0 = N w = "'""'
`
`\0
`~
`00
`
`d r.,;_
`
`0 ....
`....
`.....
`rJJ =(cid:173)
`
`('D
`('D
`
`-....J
`
`-------------'
`
`ENGINE
`GRID
`
`I WEB SERVER
`, PRIVATE DOMAIN
`r------------
`150
`
`140
`
`GRID PACKET
`PROCESSED
`
`STREAM
`OUTPUT
`
`II
`
`120
`
`FIREWAW 1--H COMMUNICATIONS
`
`I I' NElWORK
`
`PROXY
`
`192
`
`....,
`RECEIVING SYSTEM
`
`t I
`
`OUTPUT GRID! I H-LJ.-1. 196
`MEMORY
`
`FIG.1
`
`182
`I
`
`178
`I
`
`11
`
`lJ-ll
`
`PACKET
`
`Netflix, Inc. - Ex. 1011, Page 000003
`
`

`

`U.S. Patent
`
`Jul. 30, 2013
`
`Sheet 2 of 7
`
`US 8,499,023 Bl
`
`200
`
`~
`
`221
`
`223
`
`227
`
`GRID HOST1
`
`GRID HOST3
`
`URL REQUEST
`(http://GridHost11GridServleU ... )
`
`URL REQUEST
`~ttp//GridHost3/GridServleU ... )
`URL REQUEST
`(http://GridHost2/GridServleU ... )
`
`URL REQUEST
`(http://GridHost4/GridServleU ... )
`
`FIG.2
`
`Netflix, Inc. - Ex. 1011, Page 000004
`
`

`

`U.S. Patent
`
`Jul. 30, 2013
`
`Sheet 3 of 7
`
`US 8,499,023 Bl
`
`300 '-\
`
`220
`
`222
`
`224
`
`226
`
`URL REQUEST
`(http //GridHost 1/GridServleV ... )
`
`URL REQUEST
`(http://GridHost3/GridServleV ... )
`URL REQUEST
`(http://GridHos12/GridServleV ... )
`
`URL REQUEST
`(http://GridHosl4/GridServleV ... )
`
`232~
`
`236
`
`FIG.3
`
`Netflix, Inc. - Ex. 1011, Page 000005
`
`

`

`U.S. Patent
`
`Jul. 30, 2013
`
`Sheet 4 of 7
`
`US 8,499,023 Bl
`
`400
`
`~
`
`220
`
`222
`
`224
`
`226
`
`230
`
`URL REQUEST
`(http1/GridHost1/GridServleU ... )
`
`234
`
`URL REQUEST
`(http://GridHost3IGridServleU ... )
`
`URL REQUEST
`(http://GridHost4IGridServleU ... )
`
`420
`
`INTER SWITCH
`COMMUNICATION
`
`430
`
`436
`
`210
`
`FIG.4
`
`Netflix, Inc. - Ex. 1011, Page 000006
`
`

`

`U.S. Patent
`
`Jul. 30, 2013
`
`Sheet 5 of 7
`
`US 8,499,023 Bl
`
`500
`
`~
`
`220
`
`222
`
`224
`
`226
`
`230
`
`URL REQUEST
`(http//GndHost1/GndServleU ... )
`
`234
`
`URL REQUEST
`(http://GndHost3/GndServleU ... )
`
`URL REQUEST
`(http://GridHosl4/GridServleU ... )
`
`420
`
`INTER SWITCH
`COMMUNICATION
`
`430
`
`210
`
`562
`
`FIG.5
`
`Netflix, Inc. - Ex. 1011, Page 000007
`
`

`

`U.S. Patent
`
`Jul. 30, 2013
`
`Sheet 6 of 7
`
`US 8,499,023 Bl
`
`600
`
`~
`
`220
`
`222
`
`224
`
`226
`
`230
`
`URL REQUEST
`(http I/GridHost1/GridServleV ... )
`
`420
`
`INTER SWITCH
`COMMUNICATION
`
`URL REQUEST
`URL REQUEST
`(http://GridHosVGridServleV ... ) (httpY/GridHosVGridServleV ... )
`DNS ROUND
`ROBIN
`REQUESTS
`
`562
`
`FIG.6
`
`610
`
`CELL
`PHONE
`
`620
`
`210
`
`Netflix, Inc. - Ex. 1011, Page 000008
`
`

`

`U.S. Patent
`
`Jul. 30, 2013
`
`Sheet 7 of 7
`
`US 8,499,023 Bl
`
`700~
`
`710
`
`714
`
`712
`
`URL REQUEST
`(httpi/GridHos\2/GridServleU ... )
`
`URL REQUEST
`(http://GridHost1/GridServ1eU ... )
`
`GRID FARM (NETWORK)
`
`750
`
`704
`
`COMMUNICATIONS NETWORK
`
`762
`
`752
`
`localion http1/m~ostcom/gnd:
`UserProo.class (User Client Program)
`filel.dat 1Client Program Dalasel)
`
`USER'S NETWORK
`
`FIG.7
`
`Netflix, Inc. - Ex. 1011, Page 000009
`
`

`

`US 8,499,023 Bl
`
`1
`SERVLET-BASED GRID COMPUTING
`ENVIRONMENT USING GRID ENGINES AND
`SWITCHES TO MANAGE RESOURCES
`
`2
`systems, would utilize non-proprietary teclmologies and pro(cid:173)
`gramming languages and standard data transfer and commu(cid:173)
`nication protocols.
`
`BACKGROUND OF THE INVENTION
`
`SUMMARY OF THE INVENTION
`
`1. Field of the Invention
`The present invention relates, in general, to grid computing
`systems and environments, and, more particularly, a servlet(cid:173)
`based method and corresponding system for processing
`requests to grid resources and managing access to grid
`resources and transmission of resource inputs and outputs in
`a lightweight manner that is not specific to a particular grid
`implementation or programming language.
`2. Relevant Background
`In the computer industry, grid computing is growing in
`popularity to address the growing demands for on demand
`processing power and capability. Grid computing is a form of
`distributed computing in which computing resources are
`shared by numerous users and in many cases, the computing
`resources are shared across networks and across a diverse
`geographic area. Grid computing facilitates selection, aggre(cid:173)
`gation, and sharing of computing resources resident in mul(cid:173)
`tiple administrative domains and across geographic areas.
`The sharing may be based upon availability, capability, and
`cost of the resources available in a grid as well as on a user's
`quality of service requirements and users functional
`demands.
`If managed properly, grid computing can result in reduced
`cost of ownership, aggregated and improved efficiency of
`computing, data, and storage resources, and enablement of
`virtual organizations for applications and data sharing. For
`example, in a grid computing environment, all of the dispar(cid:173)
`ate computers and systems in an organization or among orga(cid:173)
`nizations can be organized and managed as a grid to become
`one large, integrated computing system. That single inte(cid:173)
`grated system can then handle problems and processes too
`large and intensive for any single computer of the organiza(cid:173)
`tion or organizations to easily handle in an efficient manner.
`While providing many advantages, grid computing is not
`being used optimally and continues to challenge the comput(cid:173)
`ing industry. Implementation and administration of grid(cid:173)
`based computing is often difficult and cumbersome. Further,
`few standards have been implemented for grid computing and
`many of the implementation and administration environ(cid:173)
`ments or teclmologies are proprietary to a particular com(cid:173)
`pany, such as a software or hardware development company.
`Another problem with grid computing is that programmers
`wishing to use grid resources usually need to learn some
`additional, grid-specific software programming language to
`take full advantage of the grid implementation. To make
`matters worse, the programmer may have to contort or modify
`their program or programs in an undesirable manner to use the
`grid resources. The programmer may also be forced to seg(cid:173)
`ment their data to effectively use the resources which may
`create a difficult task of processing the split data that is
`returned from the grid resources. Additional frustrations are
`caused when the grid environment includes firewalls or
`HTTP proxy servers that can make it hard to establish direct
`connections between user devices and grid resources, such as
`grid-available client programs or services.
`As a result of these problems or limitations with present
`grid computing environments, there remains a need for an
`improved grid computing environments that enhance the abil(cid:173)
`ity of users and programmers to access and effectively use
`resources in a grid. Preferably such a method, and related
`
`10
`
`The present invention addresses the above and other prob(cid:173)
`lems by providing a method and corresponding systems for
`managing a grid computing environment using grid engines
`( e.g., GridServlets) and grid switches. The invention provides
`a grid computing network or system that is a ubiquitous fabric
`that a programmer can plug into to provide their client pro(cid:173)
`gram or device as a grid computing resource. The use of grid
`packets and other data transmission techniques replaces the
`15 "grid" of prior systems with a "packet" computing paradigm.
`The method and system of the invention generally takes
`advantage of easily deployed, self-maintaining, readily
`understood web teclmology and object-oriented program(cid:173)
`ming (such as Java programming or software) to implement a
`20 lightweight grid computing environment or system.
`In one embodiment, the grid computing system utilizes a
`web server or web server teclmology with the addition of
`several special applications and/or objects, such as HttpServ(cid:173)
`lets and associated Java classes, adapted to facilitate the
`25 deployment and execution of a user's software to a grid of
`computer systems. These applications may be labeled "grid
`engines" or "GridServlets" that respond to users' grid com(cid:173)
`puting requests to load and execute client programs ( or
`remotely run such programs) and "grid switches" that act as
`30 front end controllers to provide access to the grid engines and
`client programs (or grid resources). In one embodiment, the
`grid computing system is entirely Java based and in this case,
`the specific architecture of servers in the grid ( or grid servers)
`is not limiting as was the case with prior grid computing
`35 systems. In some embodiments, native code is provided for
`specific architectures in other languages, such as C, C++,
`Fortran, or the like to take advantage of specific hardware
`and/or libraries. By using the method and system of the inven(cid:173)
`tion, implementing grid functionality becomes as easy as
`40 opening a URL connection. In addition, the inventive method
`and system allows grid computing to be accomplished on a
`network such as the Internet, by allowing grid compute
`requests to be made through both firewalls and HTTP proxies,
`thereby eliminating the need for a direct connection between
`45 a requesting user device or program and a client program or
`other grid resource ( as was the case with prior grid computing
`systems).
`More particularly, a method is provided for managing
`resources in a grid computing system. The method includes
`50 providing a web server running on a computer device on a
`digital communications network and providing a grid engine
`on the web server. The grid engine is adapted for processing
`grid compute requests from user programs. The method con(cid:173)
`tinues with the grid engine receiving a grid compute request
`55 from a user program. Then, the grid compute request is pro(cid:173)
`cessed by the grid engine to determine a client program
`among the grid resources and a path in the grid to the client
`program. The method includes loading and running the client
`program on the computer device to generate a client program
`60 output which is then transmitted to the user program.
`In one embodiment, the grid compute request includes a
`URL request string including a name of the client program
`and the path to the client program and may also include a
`name of the computer device hosting the web server and a
`65 path to the grid engine. The client program output may be
`transmitted to the user program as a data stream from the
`opened client program URL. The grid compute request may
`
`Netflix, Inc. - Ex. 1011, Page 000010
`
`

`

`US 8,499,023 Bl
`
`3
`also including a parameter defining a data set and this data set
`is loaded to the web server for processing on by the client
`program run by the grid engine. The grid compute request
`may in some embodiments of the method include a grid
`packet that is a client processing program which can be run or
`processed by the grid engine to process a data set and the
`processed grid packet may be returned to the user program,
`stored for later retrieval by the user program, and/or transmit(cid:173)
`ted to a grid end point device based on information/instruc(cid:173)
`tions in the grid compute request.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`10
`
`4
`to execute Java programs in response to requests made of the
`web server. Users (or user programs) of the grid computing
`system can either load their own particular Java programs via
`a servlet (i.e., the grid engine) and have the results returned to
`them, such as via an InputStream, or they can submit a small,
`packet type program ( or "grid packet") to the grid engine to be
`processed by accessing ( e.g., loaded on the web server host(cid:173)
`ing the grid engine or run remotely) client programs and then
`returned to them, such as in a Java object format or the like.
`In the following discussion, computer and network devices
`( or "elements"), such as the software and hardware devices
`within the system 100, are described in relation to their func(cid:173)
`tion rather than as being limited to particular electronic
`devices and computer architectures and programming lan-
`15 guages. Examples of implementations provided in the Java
`programming language are provided to more efficiently
`describe one useful embodiment of the invention but the
`invention is not limited to the Java prograniming language as
`those skilled in the art will readily understand how the Java(cid:173)
`based examples can be applied in other languages and other
`architectures.
`Further, to practice the invention, the computer and net-
`work devices or elements may be any devices useful for
`providing the described functions, including well-known data
`processing and communication devices and systems, such as
`application, database, web, blade, and entry level servers,
`midframe, midrange, and high-end servers, personal comput(cid:173)
`ers and computing devices including mobile computing and
`electronic devices with processing, memory, and input/output
`30 components running code or programs ("applications",
`"tasks" within such applications, and "services") in any use(cid:173)
`ful prograniming language, and server devices configured to
`maintain and then transmit digital data over a wired or wire(cid:173)
`less communications network. Data storage systems and
`35 memory components are described herein generally and are
`intended to refer to nearly any device and media useful for
`storing digital data such as disk-based devices, their control(cid:173)
`lers or control systems, and any associated software. Data,
`including transmissions to and from the elements of the net(cid:173)
`work 100 and among other components of the network/sys(cid:173)
`tems 100 in "templates" or otherwise, typically is communi-
`cated in digital format following standard communication
`and transfer protocols, such as TCP/IP, Hfrp, HTTPS, FTP,
`and the like, or IP or non-IP wireless communication proto-
`45 cols.
`FIG. 1 illustrates a simplified grid computing network or
`system 100 that is adapted according to one embodiment of
`the invention for effectively for managing resources in a grid
`computing environment. The system 100 may take a variety
`50 of forms to practice the invention and generally, may be
`arrangement of computing and/or electronic devices that are
`communicatively linked by a wired or wireless communica(cid:173)
`tions network 120 ( and network 160, which may be the same
`network such as the Internet as network 120 or a separate
`55 network such as a LAN, WAN, or the like).
`As shown, the system 100 includes a user system or user
`space 104 with a number of user devices 110 linked to a grid
`host system 130 via the communications network 120. The
`user devices 110 may be nearly any computer or electronic
`60 device capable of interfacing with a network 120, such as the
`Internet. As shown, each user device 110 includes a user
`program 112 configured for generating grid compute requests
`and transmitting such requests to the grid host system 130
`over the network 120. The user device 110 may also or alter-
`65 natively be configured to generate and/or to submit a small
`program(s) such as the illustrated grid packet(s) to the grid
`host system 130 for processing (e.g., initially shown as
`
`FIG. 1 illustrates a simplified grid computing system or
`network, adapted for managing access and use of grid
`resources according to an embodiment of the present inven(cid:173)
`tion;
`FIG. 2 illustrates in block diagram form a grid computing
`system (such as may be embodied in the system of FIG. 1)
`illustrating requesting grid resources or grid computing from 20
`a number of grid engines with a user program ( such as the user
`programs of FIG. 1);
`FIG. 3 illustrates a grid computing system similar to the
`system ofFIG. 2 and further including a firewall and/or HTTP
`proxy between the user program and the grid engines (and, 25
`therefore, grid resources or services);
`FIG. 4 shows another grid computing embodiment of the
`invention similar to the system of FIG. 3 and further including
`grid switches controlling access to grid engines (and their
`grid resources);
`FIG. 5 illustrates yet another grid computing system of the
`invention similar to the system of FIG. 4 but further includes
`a grid end point for receiving/storing output streams or grid
`packets from the grid resources ( e.g., client programs or the
`like);
`FIG. 6 illustrates another embodiment of a grid computing
`system according to the present invention that is shown to
`include "mini" grid engines to provide further access to
`resources in a public domain of a grid; and
`FIG. 7 illustrates still another embodiment of a grid com- 40
`puting system of the invention that more fully illustrates data
`flow between a user's network and a grid farm or network
`during operation of an exemplary grid computing system.
`
`DETAILED DESCRIPTION OF THE PREFERRED
`EMBODIMENTS
`
`In brief, the present invention is directed to a method of
`managing or operating a grid computing environment and
`associated grid computing systems that utilizes a grid engine
`or GridServlet configured to launch client programs or other
`resources of a grid.
`In one embodiment, the grid engine acts to process grid
`compute requests that are generated by a user program and
`transmitted over a communications network, such as the
`Internet. The grid compute requests constructed by the user
`program in one embodiment are a Uniform Resource Locator
`(URL) that includes a host name of a server hosting the grid
`engine, a path to the grid engine, a name of a client program
`to run or grid resource to access, a URL path to the client
`program along with any other information or parameters
`needed by the client program (such as the location ofa data set
`to process).
`For example, the method and system of the invention may
`build on web server technology to provide the grid engine. In
`a Java-based implementation, the ability to serve servlets is
`added to the web server to provide the web server the ability
`
`Netflix, Inc. - Ex. 1011, Page 000011
`
`

`

`US 8,499,023 Bl
`
`10
`
`5
`unprocessed grid packets 137 in memory 136 of grid switch
`134). Typically, the results or output from the grid compute
`request are transmitted to the user device 110, such as in an
`OutputStream in a Java-based embodiment.
`In other cases, though, the results may be stored in the grid 5
`host system 130, such as output streams 138 or processed grid
`packets 140 in memory 136 of a grid switch 134 as shown or
`in separate memory of host system 130 (not shown), and such
`storage may be performed until the calling program 112
`retrieves the output or results 138, 140 or in some embodi-
`ments, the results 138, 140 are later transferred to the user
`device 110 (such as based on a polling result indicating the
`user device 110 is able to receive the data over the network
`120). In yet other cases, a receiving system or grid end point
`device 190 is provided on the network 120 in user space 104
`and includes memory 192 to allow the system 190 to act as a
`repository for data output or output grid packets 196 from
`client programs or grid resources 166, 176. In other cases, the
`user program 112 may designate a grid end point to receive
`the output 196 and such end point may be another user pro(cid:173)
`gram 112 on the network 120, a program or servlet provided
`for temporarily storing output 196 for later retrieval by the
`calling user program 112, or the like. As shown, one or more
`firewalls and/or proxies (such as an HTTP proxy or the like)
`132 may be provided on the user device side of the network
`120 to control access to and from the network 120.
`As shown, the grid host system 130 may include one or
`more grid switches 134 in communication with the network
`120 to receive grid compute requests from user program 112
`after the requests are passed through the firewall/proxy 132. 30
`The grid switch 134 processes the grid compute requests to
`determine which web server 144, 152 to route the request, and
`such switching may be performed based on the request con(cid:173)
`tents, based on a DNS round robin process, or other switching
`methodology. Generally, DNS round robin functionality is
`used for load balancing and fault tolerance between the user
`space and the grid switches. Users may reference a grid
`switch 134 (e.g., grid.companyname.com) which may have
`several IP addresses and the IP address returned rotates as
`shown in the following example (which shows two requests
`and shows addresses rotating between requests) through
`available addresses each time the grid switch 134 hostname is
`resolved to an IP address.
`ultra! :/home/lyle $ nslookup www.cnn.com
`Server: ns6.attbi.com
`Address: 63.240.76.4
`Non-Authoritative answer:
`Name: cnn.com
`Addresses: 64.236.24.28, 64.236.16.20,
`64.236.16.84,
`64.236.16.116,
`64.236.24.12, 64.236.24.20
`Aliases: www.cnn.com
`ultra! :/home/lyle $ nslookup www.cnn.com
`Server: ns6.attbi.com
`Address: 63.240.76.4
`Non-authoritative answer:
`Name: cnn.com
`Addresses: 64.236.16.84, 64.236.16.116, 64.236.24.4,
`64.236.24.12,
`64.236.24.20,
`64.236.24.28,
`64.236.16.20, 64.236.16.52
`Each web server 144, 152 is configured to run or act as a
`grid engine (or GridServlet) 146, 154 (whose functions are
`explained in detail below). The grid engine 146, 154 acts in
`some cases to load and run client programs 148, 156 in
`response to grid compute requests routed to them by the grid
`switch 134. The grid engine 146, 154 may also load and/or
`generate program data sets 150, 158 which are processed or
`
`6
`operated on by the running client programs 148, 156. The grid
`engines 146,154 act to control access to grid resources and in
`this regard, are linked to client systems 164, 17 4 in user space
`104 via network 120.
`Each client system 164, 17 4 hosts or makes available one
`or more client program 166 and/or grid resource 176. These
`grid-available client programs 166 and grid resources 176 are
`called or requested by the user programs 112 via grid compute
`requests transmitted to the grid engines 146, 154. As part of
`the grid compute requests the user program 112 can indicate
`a data set or sets that should be utilized by or processed by the
`requested client program or resource 166, 176, and exemplary
`data sets 170, 182 are shown stored in memory 168, 178 on
`client systems 164,174. Of course, the data sets 170,182 may
`15 be provided on nearly any device accessible in the grid com(cid:173)
`puting system 100 and are not required to be provided by
`client systems 164, 17 4. Further, user devices 110, receiving
`system 190, and client systems 164, 174 may be provided in
`separate systems/devices as shown or may be combined into
`20 one, two, or three systems.
`Building on this general explanation of the components of
`an exemplary grid computing system 100, it may now be
`useful to more fully describe several of the more significant
`features of the system 100 to further explain how these fea-
`25 tures provide a lightweight grid computing environment. To
`simplify the description, the following detailed descriptions
`of the features are provided in a Java-based example but,
`again, the concepts described can readily be used with other
`programming languages.
`Regarding first the client programs 166 of the system 100,
`a progranimer or other entity wishing to utilize the grid 100
`writes a grid client program 166 in Java that extends the basic
`capability of an HttpServlet, as will be readily understood for
`a skilled Java progranimer. The programmer then implements
`35 all their grid client software as part of this program 166. As
`discussed above, data such as data sets 170, 182 for the grid
`client program 166 to process is input via HttpServlet mecha(cid:173)
`nisms with a grid compute request from the user program 112
`taking the form in one embodiment of a URL request string
`40 that started the HttpServlet grid client 166. Data to be
`returned to the main calling program 112 is returned via an
`OutputStream 138 from this program 166 (or running client
`program 148, 156) and a corresponding InputStream from the
`calling program 112. An alternative approach is for the user
`45 program 112 to extend and implement a GridPacket Class
`where the user's code is defined inside the extending Class
`and that Class is serialized as a Java object 116 and submitted
`for processing (e.g., unprocessed grid packets 137) by the
`user program 112 to the grid engine 146, 152 and then,
`returned 140 or 196 to the user program 112 or endpoint 190
`when processing is completed. The client programs 116, 176
`are made available to the grid engine 146, 152 via the network
`120 in the grid computing system 100.
`With the grid client programs 166 available on the grid 100,
`55 a user program or controlling program 112 can be written in
`Java and provided on a user device 110 linked to the grid host
`system 130 via network 120. The user program 112 is adapted
`to be able to initiate the grid client programs 166, 176 via or
`on any web server 144, 154 in which a grid engine 146, 156 is
`60 installed (assuming the user program 112 has access to the
`domain 186, 188 in which the grid engine 146, 156 resides as
`is explained below). During operation of the grid computing
`system 100, the user program 112 launches a grid client
`program 166, 176 by constructing a grid compute request. In
`65 one embodiment, the grid compute request is a URL which
`includes the name of the host 130 for the web server 144, 154,
`the path to the grid engine 146, 154, the name of the Java or
`
`64.236.16.52,
`64.236.24.4, 50
`
`Netflix, Inc. - Ex. 1011, Page 000012
`
`

`

`US 8,499,023 Bl
`
`7
`client program 166, 176 to run, the URL path to the Java or
`client program 166, 176 to run, and any other information or
`parameters that the grid client program 166, 176 needs such
`as the location of any data set 170, 182 to process. The
`following is an example of such a grid compute request:
`http://GridHost/
`GridServlet?class= TestRun&classpath=http :/ /MainHost/
`Classes/ &data=filel .dat
`In this example request, the "GridHost" parameter is the
`name of the system 130 that contains the web server 144 or
`152 that is or runs one of the grid engines 146, 154. The
`"/GridServlet" parameter is the path to the GridServlet or grid
`engine 146, 154 that enables the web server 144 or 152 to
`in the system 100. The 15
`function as a grid server
`"class=TestRun" portion or parameter tells the GridServlet or
`grid engine 146, 154 the location or place to load the TestRun
`Java program (class) or client program 166,176 is at the URL
`"http://MainHost/Classes." This location is also the default
`location to look for any other files that are referenced but do
`not have an explicit path defined to them such as "data(cid:173)
`file.dat" which is a parameter defined for the "TestRun" Serv-
`let or client program 166, 176 to load the file "file.dat" as a
`dataset 170, 182 to process. Once the URL or grid compute
`request is constructed in the user program 112, it can be
`opened for reading which will cause execution of the client
`program 148, 156 to begin on the "GridHost" 130 in the above
`example and the results would be provided to the user pro(cid:173)
`gram 112 via an InputStream from the opened URL.
`The grid engine 146, 154 and grid client programs 166, 176
`may also be written to provide real time interactive grid
`computing in the system 100 by adapting the client programs
`166,176 to receive their data set to process as aninputStream
`and to provide the results via an OutputStream 138. The grid
`engines 146, 154 in this example open as many client pro(cid:173)
`grams 166, 176 as necessary and when a compute request to
`process a data set 170, 182 is received from a user program
`112, the grid engine 146, 1