|Numéro de publication||US7568006 B2|
|Type de publication||Octroi|
|Numéro de demande||US 11/000,438|
|Date de publication||28 juil. 2009|
|Date de priorité||30 nov. 2004|
|État de paiement des frais||Caduc|
|Autre référence de publication||CN1783121A, CN1783121B, US20060117064|
|Numéro de publication||000438, 11000438, US 7568006 B2, US 7568006B2, US-B2-7568006, US7568006 B2, US7568006B2|
|Inventeurs||Brian Christopher Wilson|
|Cessionnaire d'origine||International Business Machines Corporation|
|Exporter la citation||BiBTeX, EndNote, RefMan|
|Citations de brevets (8), Citations hors brevets (1), Référencé par (2), Classifications (13), Événements juridiques (4)|
|Liens externes: USPTO, Cession USPTO, Espacenet|
This application is related to a commonly owned, currently pending U.S. application, entitled “Computer Grid Access Management System,” Ser. No. 10/835,454, filed Apr. 29, 2004, which is incorporated herein by reference in its entirety.
1. Field of the Invention
The present invention generally relates to networked computer systems, and more particularly, to methods and systems for executing individual design automation tasks without interference from other similar tasks being executed on the same computer or network of computers.
2. Description of the Related Art
An on-demand environment can be described as one or more discrete computers, each possessing one or more processing units (e.g., CPUs) joined together to from a computer network. The on-demand aspect is embodied by management software that receives processing requests and then applies the most appropriate resources to processing requests when available. In addition, the management software may change the resources allocated to a running process, to both increase and decrease the resources allocated to a running process, depending on a variety of factors. One embodiment of a management software product is IBM's Load Leveler® application. The management software is aware of the resources that are currently being used to satisfy processing requests as well as the resources that remain available, and is further configured to detect when computing resources are added to or removed from the on-demand environment.
The on-demand environment (also referred to as a computing grid) includes an arbitrary number of, possibly heterogeneous, computer systems. Large computing grids are capable of harnessing tremendous computing power. It has become useful for the owners of such large computing grids to accept job processing requests from unrelated entities. For example, design automation tasks such as high-level synthesis, logic synthesis, static timing analysis, placement, and physical synthesis (among others) are strong candidates for an on-demand, grid-based solution. Typically, these tasks may be characterized as being long running processes that can take multiple hours or even days to complete, and often require very large amounts of computational resources. Additionally, because the tasks require a limited amount of data and execution logic, the tasks may be transmitted over a network in a reasonable time. Because the constraining aspect is processing time, the more computational “horsepower” available to process a design automation task, the faster a job may be completed. Accordingly, maximizing the utilization of computing resources is an important goal for an on-demand grid services provider.
A grid services provider may process design automation tasks on a first come first served basis or on a reservation basis. Problems arise, however, when processing requests from different entities are allowed access to the same computing grid. First, security concerns arise where the processing request from one entity might be allowed to snoop on the activity of other tasks being processed by the computing grid or on the grid itself. Second, aside from these security concerns, design automation tasks may be very complex, and if not properly constructed, may operate incorrectly, interfering with other processes or “crashing” portions of the grid.
One common solution to this problem is to partition grid resources to a task in advance. When a new task arrives at the grid (e.g., is transmitted over a network to a “drop box” server), an estimate of resources required to complete the task is made, and a subset of grid resources may be partitioned to the new task, giving the task its own closed environment in which to execute. Doing so segregates tasks from one another, thereby preventing one task from eavesdropping on another. Further, an errant task is prevented from disrupting no more than the grid resources allocated to it due to a “crash” or other exception event.
This approach, however, may leave grid resources unused, even when available. For example, consider a grid with 32 memory units available to store data. If one process is partitioned 18 units, but only uses 12, then a second task requiring 16 units will have to wait until the first process completed, despite that collectively, only 28 units are required to complete both tasks simultaneously. Also, once a job completes, the resources partitioned to it may have to be “scrubbed.” For example, hard drives may have to be erased, and operating systems re-installed to ensure that one task did not bring in (or itself comprise) a “Trojan horse” that may either eavesdrop on subsequent activity or damage grid resources. Doing so, however, takes time and reduces the resources that are available to other tasks, which may itself cause other tasks to take longer to complete, further reducing the utilization of a computing grid.
Another approach is for the grid provider to also provide a number of pre-defined tasks that may be carried out by the computing grid. This way, parties only need to submit data components to the grid provider. This approach, however, prevents entities from developing their own design automation programs. Thus, a grid provider may not be able to provide all the services needed for a particular entity. Further, it may prevent one party from employing requisite proprietary processing techniques.
Accordingly, there remains a need for a grid services provider to maximize the availability of a computing grid while simultaneously protecting the security of unrelated processing tasks. In particular, concurrently executing design automation tasks should execute without interference from others, and conversely, should be prevented from accessing or eavesdropping on others. Additionally, the computing grid itself should be protected from intentional or unintentional harm that may be caused by processing a design automation task.
The present invention generally provides methods, systems and articles of manufacture for providing grid computing services to multiple entities. One embodiment of the present invention provides a command interpreter configured to execute a design automation task in a grid environment. The command interpreter is configured to provide developers with the flexibility to construct design automation tasks while simultaneously preventing such tasks from engaging in improper activity. The command interpreter executes each submitted design automation task using a dynamic, secure container. This allows resources allocated to a particular request to change (i) as resources are required by the process as it executes, (ii) as resources are available, and also (iii) according to predefined limits (e.g., the maximum amount of resources contracted for). At the same time, however, the design automation task supplied to the computing grid is prohibited from accessing commands (or engaging in operations) that would allow one process to eavesdrop or interfere with others, or with the grid itself.
One embodiment of the invention provides a method for accessing a computing grid. The method generally includes providing a design automation application, wherein the design automation application is configured to process a design automation task, wherein the design automation task comprises (i) a set of commands to be evaluated by the design automation application, and (ii) a set of data representing an electronic circuit; and providing an interface for a user of a computer system to transmit the design automation task to the computing grid.
Another embodiment of the invention provides a system for evaluating a design automation task. The system generally includes a computing grid, wherein the computing grid comprises a plurality of computer resources connected together to form a network of resources, and a design automation application configured to process the design automation task using the network of resources, wherein the design automation task comprises (i) a set of commands to be processed by the design automation application and (ii) a set of data representing an electronic circuit, and wherein the design automation task is configured to process the processing request using the network of resources. The system generally further includes a grid manager configured to (i) monitor the resources available in the computing grid, (ii) assign to resources from the computing grid to process the design automation task, and (iii) to receive and store results generated by processing the design automation task submitted by a requesting entity
Another embodiment of the invention provides a computer readable medium that includes instructions, which when executed by a computer system, perform operations. The operations generally include defining a design automation package, wherein the design automation application is configured to process a design automation task, wherein the design automation package comprises (i) a set of commands to be processed by the design automation application and (ii) a set of data representing an electronic circuit, and providing an interface for a requesting entity to transmit the design automation package to a computing grid. The operations generally may further include receiving, from the requesting entity, the design automation task and a request to process the design automation task, invoking an instance of the design automation application on the computing grid, providing the design automation package to the instance of the design automation application, evaluating the set of commands included in the design automation package, and returning an indication of the results of the evaluation to the requesting entity.
Another embodiment of the invention provides a computer readable medium that includes information stored thereon. The information generally includes a design automation application configured to process a design automation task, wherein the design automation task comprises (i) a set of commands to be processed by the design automation application and (ii) a set of data representing an electronic circuit. The information generally may further include a grid manager configured to (i) monitor the resources available in the computing grid, (ii) assign to resources available on the computing grid to process the design automation task, and (iii) to receive and store results generated by processing the design automation task submitted by a requesting entity.
So that the manner in which the above recited features, advantages and objects of the present invention are attained and may be understood in detail, a more particular description of the invention, briefly summarized above, may be had by reference to the embodiments thereof which are illustrated in the appended drawings. Note, however, that the appended drawings illustrate only typical embodiments of this invention and are, therefore, not to be considered limiting of its scope, for the invention may admit to other equally effective embodiments.
The present invention generally pertains to on-demand access to computerized resources. Computerized resources are made available in response to the actual needs generated by a processing request, rather than projected needs. Embodiments of the invention provide a computing environment wherein multiple processing requests may be executed simultaneously without interference from (or causing interference to) other tasks. Processing requests consume only the capacity and resources they need, when the capacity and resources are needed, and in one embodiment, are charged accordingly. As a result, the cost of computerized resources substantially matches the computerized resources actually used. Further, because resources are not partitioned to a particular task in advance, resource utilization is increased, and the downtime associated with manually partitioning resources between tasks is substantially reduced, if not eliminated entirely.
The following description references embodiments of the invention. It should be understood, however, that the invention is not limited to any specific described embodiment. Instead, any combination of the following features and elements, whether related to described embodiments or not, is contemplated to implement and practice the invention. Furthermore, in various embodiments, the invention provides numerous advantages over the prior art. Although embodiments of the invention may achieve advantages over other possible solutions or over the prior art, whether or not a particular advantage is achieved by a given embodiment is not limiting of the invention. Thus, the following aspects, features, embodiments and advantages are merely illustrative and are not considered elements or limitations of the appended claims except where explicitly recited in a claim. Likewise, reference to “the invention” shall not be construed as a generalization of any inventive subject matter disclosed herein and shall not be considered to be an element or limitation of the appended claims except where explicitly recited in a particular claim.
One embodiment of the invention is implemented as a program product for use with a computer system such as, for example, the network environment 100 shown in
In general, the routines executed to implement the embodiments of the invention, may be part of an operating system or a specific application, component, program, module, object, or sequence of instructions. The computer program of the present invention typically is comprised of a multitude of instructions that will be translated by the native computer into a machine-readable format and hence executable instructions. Also, programs are comprised of variables and data structures that either reside locally to the program or are found in memory or on storage devices. In addition, various programs described hereinafter may be identified based upon the application for which they are implemented in a specific embodiment of the invention. However, it should be appreciated that any particular program nomenclature that follows is used merely for convenience, and thus the invention should not be limited to use solely in any specific application identified or implied by such nomenclature.
As described above, an on-demand environment may comprise a collection of, possibly heterogeneous, computing systems connected together to form a network. In one embodiment, a grid entity may itself comprise a networked computing system such as a computing cluster. For example, a Beowulf cluster is a well known system design for connecting a set of inexpensive personal computer systems together so that they appear as a single multi-processor computer system. Embodiments of the invention manage networks of multiple computer systems that all have distinct identities. Within that environment a single entity may comprise a Beowulf cluster.
The independent systems managed by the grid network are each available to be assigned particular tasks. Generally, the computing systems included in the on-demand environment are available to perform tasks assigned by a grid manager. In one embodiment, the grid manager may comprise IBM's Load Leveler® software application.
The grid management system is responsible for assigning grid consumable resources to processing tasks. Consumable resources are assets available on machines in a computing grid. They are called “resources” because they model the commodities or services available on machines (e.g., CPUs, real memory, virtual memory, software licenses, and disk space, or, with less granularity, entire systems). They are considered “consumable” because job steps for a particular running task may use specified amounts of these commodities when the step is running. Once the step finishes, the resource becomes available for another job step or other task.
In one embodiment, a computing grid may be used to process design automation tasks including high-level synthesis, logic synthesis, static timing analysis, placement, physical synthesis, or wiring. Generally, an entity wishing to submit one of these tasks for processing assembles the necessary client data and controls (collectively, a processing task or request) and transmits the request to the computing grid, typically using a secure connection (e.g., SSL/TLS, S/MIMIE, HTTPS, or other protocol used to encrypt and transfer data across an insecure communications medium).
Once received by the computing gird, newly submitted tasks may be retrieved from a drop-box server and scheduled for execution on the gird by a secure design automation application. As described further below, the client data and controls submitted with a task may be used as input to the secure design automation application. Using grid resources, the application executes the user supplied controls in a manner that prevents client controls from executing malicious code or gathering unauthorized information. The client controls define the operations, calculations, and the like on the data. Grid security may be provided at the application level, and accordingly, the grid does not require that consumable resources to be partitioned among concurrent discrete tasks. Once processing is complete, the results may be stored in the drop-box server or may be returned to the requesting entity via a secure connection.
The grid system 115 illustrates components included in the on-demand environment, according to one embodiment of the invention. All remote communication to and from the grid system 115 may occur through gateway/firewall 120. As those skilled in the art understand, a gateway may be used to route incoming communications from an external network to a destination inside the on-demand environment 115. As illustrated, all communication are also processed using gateway/firewall 120 that may be used to monitor network traffic (e.g., data packets) and determine which ones may be forwarded to computer systems or processes behind the gateway/firewall 120.
In one embodiment, a HTTP server 130 may be configured to provide client systems 105 1-N a web-based interface to submit processing requests (and retrieve results) from grid system 115. Accordingly, HTTP server 130 may store a set of relatively static HTML documents to display an interface to a client 105 and to transfer data between them (e.g., using GET and POST methods) and grid system 115. Application server 135 may allow clients to access applications and databases that are managed by the server 135. The application server 135 handles all the application operations and connections for the clients 105. In one embodiment, grid system 115 may include drop box server 140 that is configured to store processing requests submitted by clients 105 along with results generated from a processing request for retrieval by a client 105. Detailed descriptions of access management techniques and the drop box server are described in commonly owned, pending application entitled “Computer Grid Access Management System”.
The computing grid 145 includes a plurality of grid elements 150. The grid elements 150 collectively represent the computational resources available for allocation to various tasks. It should be noted that each of the grid elements of
The grid system 115 may also include a grid manager 136. The grid manager 136 dispatches the processing requests initiated by the Application Server 135 to the computing grid 145, the grid resources that are currently consumed and available (i.e., grid elements 150), and also manages the state of the computing grid 145 (e.g., as computer systems are added or removed from the computing grid). As illustrated in
Although components of the grid system 115 are illustrated in
Client computer system 105 includes network interface 232 that allows client computer system 105 to communicate with the on-demand grid system 115. Client computer system 105 generally includes a central processing unit (CPU) 240 connected via a bus 230 to memory 210 and storage 245. Typical storage devices include IDE, SCSI, or RAID managed hard drives. Although shown as a single unit, it may comprise a combination of both fixed and removable storage devices, such as fixed disc drives, floppy disc drives, tape drives, removable memory cards, or optical storage. Additionally, network storage devices such as AFS, NFS, or GSA may be used. Memory may include memory storage devices that come in the form of chips (e.g., SDRAM or DDR memory modules).
Client system 105 runs an operating system 212, (e.g., a Linux® distribution, Microsoft Windows®, IBM's AIX®, FreeBSD, and the like) that manages the interaction between hardware components and higher-level software applications such as development application 215 used to construct a design automation package 220. Client system 105 may further include I/O devices such as a mouse, keyboard, and monitor, along with other specialized hardware.
In one embodiment, a user may compose a design automation package 220 using development application 215 shown residing in memory 210. The design automation package 220 may comprise a data component and a set of commands. For example, the data component may comprise data used for applications such as high-level synthesis, logic synthesis, static timing analysis, placement, physical synthesis, or wiring, and the like. Such data may include the netlist information that describes a particular electronic or integrated circuit. As those skilled in the art will understand, a netlist is a description of an electronic circuit on a system consisting of all of the circuit element names/reference designators, listed with their input and output signal names. Netlists are the primary description of a circuit used for design automation applications. Example formats for netlists include industry standard formats, including EDIF (Electronic Design Interchange Format), Verilog, DEF and PDEF.
Design automation package 220 may also include a set of commands, typically expressed as a script. A user defines the command script according to a particular e-business offering offered by the grid provider (i.e., design automation application 268). The command script allows a client to control and direct the activity of application 268 analyzing or operating upon an electronic circuit design as represented using netlist data. For example information communicated by this mechanism may include performance expectations such as the “cycle time” or the speed at which a circuit is expected to perform. Together, a processing request (or design automation task) comprises the collection of data and set of commands to test, inspect, or otherwise operate upon the data. The commands available to construct a script are defined by the service provider. In one embodiment, the commands available to construct a command script are limited to commands associated with design automation tasks.
After composing a design automation package 220, a user may deliver it to grid system 115 for processing. The package is received by grid management system 202.
Grid management system 202 is connected to network 110 using network interface 265. The grid management system 202 includes bus 258 connecting CPU 264, display 260, storage 262, network interface 265, and memory 250. As illustrated in
As illustrated in
In one embodiment, the design automation application 268 may comprise a command interpreter process running on grid element(s) 150 that interprets a script composed according to a scripting language. In a particular embodiment, the command script is composed using the Tcl language, and the design automation application may comprise a Tcl command interpreter. As those skilled in the art understand, Tcl is an interpreted computer language designed for design automation tool extension and control as well as other general computer tasks such as file manipulation that offers a high degree of flexibility. While Tcl is the predominant scripting and control language for Design Automation tools, Perl, and other scripting languages may be used.
The Tcl command interpreter provided to execute package 220 may be both extended and limited. Specifically, in one embodiment, the Tcl command interpreter may be extended by adding custom libraries, commands and routines that a user may include in a command script. The command interpreter may be limited by disabling scripting commands that would allow the command script included in one processing request to eavesdrop or interfere with others. In one aspect, prohibiting the use of certain scripting commands is a general assertion about which commands a thorough design automation application may require to evaluate a particular circuit design.
Further, spawning a modified command interpreter for each processing request creates a protected environment that allows the grid system 115 to process multiple packages 220 simultaneously. The modified interpreter acts as a secure container to execute the command script inside the design automation application 268. Within this environment, the child interpreter consumes grid resources, as needed and available, to complete the processing request. Accordingly, the grid resources being used may vary over the course of executing a particular design automation task.
Aliased commands allow a user to invoke a “safe” version of an otherwise, prohibited command. For example, an aliased command may allow a command script to write to files created by the command script to store results data, but prohibit the script from writing to system files.
In addition, the command set understood by the master command interpreter 314 may be extended by the use of libraries 326. As those skilled in the art understand, a library is a collection of subroutines used to develop a software application. Libraries differ from executable programs in that they are not independent programs; rather, they are “helper” code that provides services to some other independent program.
In one embodiment, the child interpreter 315, may comprise a subset of the commands available to the master command interpreter 314. As illustrated, the child interpreter 314 includes visible commands 322 that are available for an individual client to compose a command script 310. Aliased commands 334 provide an alternate version of a particular command so that users may still execute an otherwise prohibited command in an acceptable fashion. Hidden commands 336 are commands unavailable for a client to include in command script 310. For example, the child interpreter provided with a particular design automation application 268 may prohibit client scripts from invoking any system or shell commands, performing file input or output directly, accessing network services, and other commands unnecessary to perform design automation tasks. At the same time, the child interpreter 315 may be configured to request resources from the grid manager 136, or request the command interpreter to carry out actions that it cannot carry out directly.
In an active computing grid, multiple child interpreters may be invoked to process different design automation tasks provided by different, even competing entities. Each child interpreter has access, or can request and acquire, the resources to complete a design automation task, while also prohibiting the design automation task from engaging in unwanted behavior.
Using the definition of a design automation application 268 as described herein, users may construct a command script to process a design automation task in a computing grid. In one embodiment, the grid provider makes the definition of the child interpreter available to an interested party. The description may include all the functions (e.g., command inputs and outputs) available to compose a command script 310. Together, the design automation application 268 is constructed to use package 220 that includes command script 310 and client data 312 as input for processing. The design automation application 314 executes securely using grid resources dynamically assigned to it by the management application 254. Each invocation of the design automation application 268 is processed on the grid system independently of others.
At step 406, after a connection is established, a package that includes both the netlist, the command script, and any other client data is transmitted to the grid manager 136. Once transmitted, the client waits for a result from the grid system 115. In one embodiment, the client system may be notified of a result using E-mail. Alternatively, a user of the client system my periodically establish a connection with the grid system to determine whether any results are available to retrieve form a drop box server. However notified, the client 105 retrieves result data from the grid system at step 408, if not included in the result notification
At step 505 the package is dispatched to the grid system 115 for execution and processed at step 506. In one embodiment, this may comprise invoking a design automation application 268 that includes a Tcl child interpreter and providing the command script included with the package as input data to the child interpreter. The child interpreter executes each command included in the command script. While the design automation application processes the command script 310, resources used by the design automation application 268 are monitored. For example, grid status monitor 256 may assign additional resources to the executing task. Alternatively, or in addition, the design automation application 268 may be configured to request (or to consume, so long as available) additional computing resources (e.g., grid elements 150) while processing command script 310.
At step 508, after the design automation application has completed processing the command script (or possibly after an exception has occurred), the management application 254 stores results data in a return queue (e.g., the drop box server 140). Alternatively, the management application 254 may transmit the results to client 105 using an appropriate communications channel.
Next, at step 620, sequential evaluation of the commands included in the command script begins. As those skilled in the art understand, the sequential evaluation of a command script 310 (e.g., a script written in Tcl) may include a series of branching, conditional and looping commands, as well as jumps to and from subroutines. In one embodiment, a grid status monitor 256 may be configured to observe what grid resources are being consumed by a processing task at any given time, and add or remove resources to a particular processing task as needed. Alternatively, or additionally, the design automation application 268 may be configured to consume additional grid resources as available to complete the processing request.
At step 630, the next command is selected for execution following the language semantics. If the command is an authorized command for invocation by the child interpreter, then the command is executed at step 650. If not, exception handling occurs at step 640. For example, the design automation application 236 may cease evaluating the command script 310. Alternatively, it may try to recover or continue without executing the prohibited command. As this occurs, any results data generated by the evaluation of the command script 310 may be stored at step 660. Steps, 630, 650 and 660 repeat until the script is completed (or terminated due to an exception at step 640). Once completed, results may be returned to the client 105 (e.g., in an email message) or stored in drop box server 140 for later retrieval (step 670).
Embodiments of the present invention allow a grid services provider to define a design automation application to evaluate (execute) command scripts provided by different clients. In a particular embodiment, the design automation application is constructed by defining Tcl child interpreters to prohibit access to commands that could be used to comprise the security of the grid system. Doing so allows different invocations of the design automation application to execute concurrently in the grid system without the requirements of system partitioning or resource scrubbing. Thus, the efficiency of the grid system is maximized while also increasing the overall security of the grid system.
While the foregoing is directed to embodiments of the present invention, other and further embodiments of the invention may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.
|Brevet cité||Date de dépôt||Date de publication||Déposant||Titre|
|US6519568||23 déc. 1999||11 févr. 2003||Schlumberger Technology Corporation||System and method for electronic data delivery|
|US6643683 *||8 mai 2000||4 nov. 2003||International Business Machines Corporation||Interactive client-server environment for performing collaborative timing analysis of circuit designs|
|US7080120 *||19 janv. 2001||18 juil. 2006||Digital Orchid, Inc.||System and method for collaborative processing of distributed applications|
|US20030079121||19 oct. 2001||24 avr. 2003||Applied Materials, Inc.||Secure end-to-end communication over a public network from a computer inside a first private network to a server at a second private network|
|US20040098447 *||14 nov. 2002||20 mai 2004||Verbeke Jerome M.||System and method for submitting and performing computational tasks in a distributed heterogeneous networked environment|
|US20040193679||28 mars 2003||30 sept. 2004||General Motors Corporation||Computerized system for network-based management of engineering projects|
|US20050015439 *||15 juil. 2003||20 janv. 2005||Ekambaram Balaji||Flexible architecture component (FAC) for efficient data integration and information interchange using web services|
|US20050078822||9 janv. 2004||14 avr. 2005||Eyal Shavit||Secure access and copy protection management system|
|1||U.S. Appl. No. 10/835,454, entitled "Computer Grid Access Management System" filed Apr. 29, 2004 by William A. Oswald et al.|
|Brevet citant||Date de dépôt||Date de publication||Déposant||Titre|
|US8032846||4 oct. 2011||Synopsys, Inc.||Efficient provisioning of resources in public infrastructure for electronic design automation (EDA) tasks|
|US20050078822 *||9 janv. 2004||14 avr. 2005||Eyal Shavit||Secure access and copy protection management system|
|Classification aux États-Unis||709/205, 717/102, 709/225, 709/204, 709/218, 717/115, 716/108|
|Classification internationale||G06F9/44, G06F17/50, G06F15/173, G06F15/16|
|14 déc. 2004||AS||Assignment|
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:WILSON, BRIAN C.;REEL/FRAME:015479/0225
Effective date: 20041129
|11 mars 2013||REMI||Maintenance fee reminder mailed|
|28 juil. 2013||LAPS||Lapse for failure to pay maintenance fees|
|17 sept. 2013||FP||Expired due to failure to pay maintenance fee|
Effective date: 20130728