US 7,047,232 B1Grant
Parallelizing applications of script-driven tools
Issue Date:2006-05-16
•36 Claims
•29 Drawing Sheets
Abstract
A system and method for parallelizing applications of script-driven software tools. Scripts in the software tool scripting language are automatically analyzed in order to produce a specification for a parallel computation plus a set of “script fragments”, the combination of which is functionally equivalent to the original script. The computational specification plus the script fragments are then executed by a parallel runtime system, which causes multiple instances of the original software tool and/or supplemental programs to be run as parallel processes. The resulting processes will read input data and produce output data, performing the same computation as was specified by the original script. The combination of the analyzer, runtime system, original software tool, and supplemental programs will, for a given script and input data, produce the same output data as the original software tool alone, but has the capability of using multiple processors in parallel for substantial improvements in overall “throughput”. The invention includes computer program embodiments of an automatic script analyzer.
Metadata
Assignee
- Ab Initio Software Corporation
Inventor
- Martin Serrano
Application Information
Application Number:US 09/229,849
Filing Date:1999-01-13
Priority Date:1999-01-13
Art Unit:2162
Classifications
IPC:
G06F17/30
Patent Drawings (29 sheets)
Description
Notice of Copyrights
[0001] A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by any one of the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.
Technical Field
[0002] The invention relates to the control of computations in data processing systems and, more particularly, to parallelizing applications of script-driven tools.
Background
[0003] Computational speeds of single processor computers have advanced tremendously over the past three decades. However, many fields require computational capacity that exceeds even the fastest single processor computer. An example is in transactional processing, where multiple users access computer resources concurrently, and where response times must be low for the system to be commercially acceptable. Another example is in database mining, where hundreds of gigabytes of information must be processed, and where processing data on a serial computer might take days or weeks. Accordingly, a variety of “parallel processing” systems have been developed to handle such problems. For purposes of this discussion, parallel processing systems include any configuration of computer systems using multiple central processing units (CPUs), either local (e.g., multiprocessor systems such as SMP computers), or locally distributed (e.g., multiple processors coupled as clusters or MPPs), or remotely, or remotely distributed (e.g., multiple processors coupled via LAN or WAN networks), or any combination thereof.
[0004] However, despite the existence of such parallel processing systems, not all programs or software tools are designed to take advantage of parallel processing. For example, several commercially important software tools share the following characteristics:
-
- [0005] The software tool is capable of performing a variety of functions.
- [0006] The invocation of those functions is controlled by a “scripting language” which specifies a series of processing steps and the interchange of data between those processing steps.
- [0007] Users write applications using the combination of the tool and its scripting language.
- [0008] The software tool makes no or minimal use of parallel processing.
[0009] One example of such a software tool is the “SAS® Software System”, a data analysis system produced by the SAS Institute, Inc. The functions provided by this tool include data transformation, data aggregation, dataset management, and a wide variety of statistical procedures. Users build SAS applications by writing scripts in a language which is also called “SAS”. A second example of such a tool is “SyncSort®” produced by Syncsort Inc. The functions provided by this application include data filtering, data sorting, and data aggregation. Users build “Syncsort” applications by writing “Syncsort” scripts.
[0010] When applications built with such software tools are used to process large quantities of data, execution times can become quite large. Parallel processing, in which large numbers of processors can be applied to a single application, has the potential to speed up such data-intensive applications. Ideally, a job which took 10 hours running on a single processor might take as little as 10 minutes running on 60 processors. Such a performance improvement is, of course, dependent on having software which is capable of utilizing the parallel processing system.
[0011] Users of these software tools are not, in most cases, willing to learn how to use a new and/or different tool or to modify existing applications of the tool. For example, a user of SAS generally would not be willing to learn an entirely new scripting language or to modify existing SAS applications. In order to bring the benefits of parallelism to such users, the inventor has determined that it would be desirable to automatically parallelize applications of the tool, as expressed in the scripting language.
Summary
[0012] The invention includes a system and method for parallelizing applications of certain script-driven software tools. In the preferred embodiment, scripts in the software tool scripting language are automatically analyzed in order to produce a specification for a parallel computation plus a set of “script fragments”, the combination of which is functionally equivalent to the original script. The parallel computation specification plus the script fragments are then executed by a parallel runtime system, which causes multiple instances of the original software tool and/or supplemental programs to be run as parallel processes. The resulting processes will read input data and produce output data, performing the same computation as was specified by the original script. The combination of the analyzer, runtime system, original software tool, and supplemental programs will, for a given script and input data, produce the same output data as the original software tool alone, but has the capability of using multiple processors in parallel for substantial improvements in overall “throughput”.
[0013] In one aspect, the invention includes a method, system, and computer program for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system. In another aspect, the invention includes a method, system, and computer program for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system.
[0014] The details of one or more embodiments of the invention are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the invention will be apparent from the description and drawings, and from the claims.
Description of Drawings
[0015] FIG. 1 is a data flow diagram of a preferred embodiment of the invention.
[0016] FIG. 2 is a data flow diagram showing the preferred method for automatically analyzing an initial script and producing a specification of a parallel computation plus script fragments.
[0017] FIG. 3 is an example of a serial dataflow graph in graphical form.
[0018] FIG. 4 is an example of a parallel dataflow graph in graphical form.
[0019] FIG. 5 shows an example of an initial script and a representation of the sequence of statements it contains.
[0020] FIG. 6 is a diagram showing examples of dataset table, processing step, and dataset access tables.
[0021] FIG. 7 is a flowchart showing an example of converting a sequence of steps into a serial dataflow graph.
[0022] FIG. 8 is a table showing a repertoire of parallelization methods.
[0023] FIG. 9 is a flowchart showing the preferred method for parallelizing a serial dataflow graph.
[0024] FIG. 10 is a diagram showing examples of initial parallel dataset, processing step, and data access tables.
[0025] FIG. 11 is a diagram showing the parallel dataset, processing step, and dataset access tables of FIG. 10 after parallelization but before resolution of conflicts.
[0026] FIG. 12 is a flowchart showing a preferred method for resolving partitioning conflicts.
[0027] FIG. 13 is a diagram showing FIG. 11 after resolution of Application Step 1 of the parallel processing step table.
[0028] FIG. 14 is a diagram showing FIG. 13 after resolution of Application Step 2 of the parallel processing step table.
[0029] FIG. 15 is a diagram showing FIG. 14 after resolution of Application Step 3 of the parallel processing step table.
[0030] FIG. 16 is a flowchart showing a preferred method for generating script fragments.
[0031] FIG. 17 shows an example of a script fragment file containing several scripts.
[0032] FIG. 18 is a diagram showing FIG. 15 after generation of script fragments.
[0033] FIG. 19 is a flowchart of one method of generating a parallel computation specification.
[0034] FIG. 20 is a diagram showing the generation of temporary datasets.
[0035] FIG. 21 is a diagram showing the final parallel computation specification 3.
[0036] FIG. 22 is a dataflow diagram showing an example of parallelizing the COPY operation.
[0037] FIG. 23 is a dataflow diagram showing an example of parallelizing the AGGREGATE operation.
[0038] FIG. 24 is a block diagram showing one method for storing a partitioned dataset.
[0039] FIG. 25 is a dataflow diagram of local-global parallelization.
[0040] FIG. 26 is a dataflow diagram showing an example of External Parallelism.
[0041] FIG. 27 is a dataflow diagram showing an example of Statement Decomposition.
[0042] FIG. 28 is a dataflow diagram showing an example of a serial SAS script that uses the MEANS procedure to calculate descriptive statistics on a dataset and produce an output file.
[0043] FIG. 29 is a dataflow diagram showing an example of a serial SAS script that uses the FREQ procedure to calculate table driven statistics on a dataset and produce an output file.
[0044] FIG. 30 is a dataflow diagram showing an example of a serial SAS script that uses the UNIVARIATE procedure to calculate univariate statistics on a dataset and produce an output file.
[0045] Like reference numbers and designations in the various drawings indicate like elements.
Detailed Description
Overview
[0046] FIG. 1 is a data flow diagram of a preferred embodiment of the invention. A software tool script 1 in a language such as SAS is automatically analyzed 2 in order to produce a specification for a parallel computation 3 plus a set of “script fragments” 4. The combination of the parallel computation specification 3 plus the script fragments 4 is functionally equivalent to the original script 1. The parallel computation specification plus the script fragments are then executed by a parallel runtime system 5, which may be, for example, the Co>Operating System™ run time system from Ab Initio Software Corporation. Such execution causes multiple instances of the original software tool 6 and/or supplemental programs 7 to be run in parallel. The resulting processes 6, 7 will read input data 8 and produce output data 9, performing the same computation as was specified by the original script 1. The combination 10 of the analyzer, runtime system, tool, and supplemental programs will, for a given script 1 and input data 7, produce the same output data 8 as the original software tool 6 alone, but uses multiple processors in parallel to obtain substantial improvements in overall “throughput”.
[0047] In order to apply the preferred embodiment, the software tool 6 and scripting language for each script 1 should satisfy certain conditions:
-
- [0048] The scripting language should consist of sequences of statements, such as processing steps and dataset definitions (e.g., files, databases, temporary datasets).
- [0049] The scripting language should specify, explicitly or implicitly, any data read/written by the processing steps. This may include temporary datasets used to pass information between processing steps; external datasets defined in dataset definition statements; and external datasets referenced (perhaps implicitly) within processing steps.
- [0050] Methods should be known (e.g., from conventional algorithms) to parallelize at least some of the processing steps. Parallelization methods include partitioning data into subsets and running an indicated processing step on each subset; inserting a separately available parallel implementation of the procedure; and dividing data into partitions and running a “global procedure” on each subset, then running a “local procedure” on the output of the global procedure (the global and local procedures may preferably—but need not necessarily—be implemented in the base scripting language).
[0051] FIG. 2 is a data flow diagram showing the preferred method for automatically analyzing 2 an initial script 1 and producing a specification of a parallel computation 3 plus script fragments 4. The script analysis method 2 may be implemented as follows:
-
- [0052] Step 101: Divide the input script 1 into a sequence of statements 102.
- [0053] Step 103: Process the sequence of statements 102 so as to produce a serial dataflow graph 104 representing the exchange of data between processing steps.
- [0054] Step 105: Parallelize the serial dataflow graph 104, thereby producing a parallel dataflow graph 106.
- [0055] Step 107: Optionally, analyze the parallel dataflow graph 106 to generate “script fragments” 4, to allow the original script-driven application to execute some of the processing steps.
- [0056] Step 108: The resulting dataflow graph 106 may then be transcribed to a specification of a parallel computation 3.
[0057] At several points in the algorithm, the computation being performed is represented as “dataflow graphs”. There are two cases: the serial dataflow graph 104, which represents the computation as performed, serially, by the original application; and the parallel dataflow graph 106, which represents the computation as performed, in parallel, by the combination of the parallel runtime system 5, the original software tool 6, and supplemental programs 7 (described further below). These dataflow graphs 104, 106 may be represented in various ways, but most often are represented either in graphical form (e.g., FIG. 3 ) or as tables representing the vertexes and edges of the graph (e.g., FIG. 6 ). Both notations may be used as convenience dictates.
[0058] FIG. 3 is an example of a serial dataflow graph 104 in graphical form. Such a graph typically has of a set of vertexes which represent, for example, the dataset(s) 201, 202 being read by the script; the dataset(s) 208 being written by the script; the processing Steps 203, 205, 207 contained in the script; and any intermediate results 204, 206 passed from one step to another, either explicitly or implicitly.
[0059] A typical serial dataflow graph 104 also has a set of directed edges 220–226 indicating the datasets accessed by each processing step. In the illustrated embodiment, edges directed into processing Steps 220, 221, 223, 225 indicate that a dataset/intermediate result is being read, while edges directed out of a processing Step 222, 224, 226 indicate that a dataset/intermediate result is being written by a processing step.
[0060] FIG. 4 is an example of a parallel dataflow graph 106 in graphical form. Typically, a parallel dataflow graph is identical to the corresponding serial dataflow graph except for the following:
-
- [0061] Some of the original processing Steps 203, 205 have been marked for parallel execution (indicated by heavy line weight).
- [0062] Some of the original intermediate results 204, 206 have been marked as being “partitioned” datasets (indicated by heavy line weight).
- [0063] Some of the original dataset accesses 220, 221, 222, 223, 224 are marked as accessing parallel data (indicated by heavy line weight).
- [0064] Some new intermediate results 212, 213, 215, 217, processing Steps 210, 211, 214, 216, and dataset accesses 227–234 have been added in order to partition data as required by various processing steps. Some of the new intermediate results 212, 213, 215 are marked as partitioned. Some of the new processing Steps 210, 211, 214 are marked for parallel execution. Some of the new dataset accesses 228, 230, 231, 232, 233 are marked as accessing parallel data.
- [0065] Notations as to partitioning key (e.g., “By v2, v3”) have been added to various processing Steps 205, datasets 215, 206, and dataset accesses 223, 224, 232, 233. These notations indicate the manner of data partitioning, as will be explained below.
[0066] While the invention has general applicability to parallelizing applications based on script-driven tools, the inventive method does require tailoring for each specific script-based tool, based on details of the facilities provided by the application and the semantics of the application's scripting language. The inventive method also requires some tailoring to the specific parallel runtime system being used. Given the methods contained herein plus the application-specific information just noted, such tailoring can be done by a programmer of ordinary skill. Details of how to address some specific issues which arise in parallelizing SAS applications are set forth below.
Illustrative Example of a Script-Driven Application
[0067] In order to illustrate some of the problems addressed by the invention, a hypothetical data analysis program called analyze will be described, along with its scripting language. The purpose of this hypothetical program and scripting languages is to illustrate features of scripting languages which are common and conventional, and to provide a basis for various examples which will be used to illustrate methods of parallelizing applications of script-driven tools.
[0068] The hypothetical “analyze” program has the following basic capabilities:
-
- [0069] Reading data from files or relational databases.
- [0070] Writing data to files or relational databases.
- [0071] Transforming one dataset to another by performing simple calculations on each record of a dataset.
- [0072] Concatenating datasets.
- [0073] Computing the aggregate functions “SUM”, “MIN”, and “MAX”. These aggregate functions can be applied to the full dataset. Alternately, a “grouped aggregate” may be computed (as in the SQL “GROUP BY” or SAS “BY” and “CLASS” statements). This will be illustrated below.
- [0074] Analyzing data by application of an analysis algorithm.
[0075] 1. Invoking the Application
[0076] In this illustration, the application is invoked via a “command line” which specifies the name of the application (“analyze”), the name of a file containing a script, and zero or more command-line parameters. For example, the following command line would run the “analyze” application, using the script “script1” and specifying the command-line parameter “datafile1”:
[0077] analyze script1 datafile1
[0078] Command-line parameters may be referenced from within the script, as necessary, by a construct of the form $<number>, such that $1 will refer to the first command-line parameter, $2 will refer to the second command-line parameter, and so forth. References to command line parameters may be used in place of filenames in dataset declarations.
[0079] 2. Dataset Declarations
[0080] A dataset is a sequence of records. In the illustrated example, each record consists of a list of space-separated data fields, and the first record of a dataset contains the names of the data fields (for brevity sake, some examples will omit the list of field names). For example:
[0081]
| custno | month | year | balance | limit |
|---|---|---|---|---|
| 00001 | 01 | 98 | 0400 | 1000 |
| 00001 | 02 | 98 | 0600 | 1000 |
| 00001 | 03 | 98 | 0200 | 1000 |
| 00002 | 01 | 98 | 0100 | 3000 |
| 00002 | 02 | 98 | 0000 | 3000 |
[0082] Datasets may be declared as follows:
INPUT datasetname filename
-
- [0083] Declares a dataset to be read. The “filename” gives the name of the file containing the data. The “datasetname” may be used to refer to the dataset elsewhere in the script.
OUTPUT datasetname filename - [0084] As above, but declares a dataset to be written by the application.
TEMP datasetname filename - [0085] As above, but declares a temporary dataset to be used within the application.
DB_IN datasetname tablename - [0086] Like the INPUT statement, but gets its data from a relational database table called tablename. The type of the data is determined by querying the database.
DB_OUT datasetname tablename - [0087] Like the OUTPUT statement, but sends its data to a relational database table called tablename.
- [0083] Declares a dataset to be read. The “filename” gives the name of the file containing the data. The “datasetname” may be used to refer to the dataset elsewhere in the script.
[0088] For example, if data to be processed is in a file, an input dataset might be declared as follows:
[0089] INPUT customers customers.dat
[0090] Alternatively, if the data was in a database table, an input dataset might be declared as follows:
[0091] DB_IN customers cust_table
[0092] A command line parameter might also be used to name a file for a dataset. For example:
[0093] INPUT customers $1
[0094] 3. Processing Steps
[0095] The hypothetical analyze application defines the following processing steps: copy, concatenate, aggregate, and analyze. Each of these processing steps produces a single output and, except for the concatenate step, each step gets its data from a single input.
[0096] By default, the output of one processing step will be used as the input of the next processing step. For example, in the following script step1's output will be used as step2's input:
[0097] step1
[0098] step2
[0099] If a data statement comes immediately before a processing step, then the processing step will get its input from the data statement. Similarly, if a data statement comes immediately after a processing step, then the processing step will write its data to the specified dataset. For example, in the following script step1 will read its input from the indata dataset and write its output to the outdata dataset:
[0100] INPUT indata input.data
[0101] step1
[0102] OUTPUT outdata output.data
[0103] These rules may be overridden by adding a clause of the form OUTPUT=dataset or INPUT=dataset to any processing step. For example, in the following script step1 will get its data from indata and write to outdata:
[0104] INPUT indata input.data
[0105] OUTPUT outdata output.data
[0106] step1 INPUT=indata OUTPUT=outdata
[0107] 4. The Copy Statement
[0108] The copy statement has the following syntax:
-
- [0109] COPY field=expression, field=expression . . .
[0110] The copy statement copies one dataset to another. Each record in the output dataset is constructed by evaluating the indicated expressions, with variables in the expressions standing for fields in the input record. For example, suppose the following dataset is to be processed:
[0111]
| v1 | v2 | v3 | |
|---|---|---|---|
| 1 | 2 | 3 | |
| 2 | 4, | 2 | |
[0112] Here is a sample script:
[0113] INPUT indata input.data
[0114] COPY v1=v1, v2=v2, v3=v3, v4=v1+v2+v3
[0115] OUTPUT outdata output.data
[0116] The following output would be produced:
[0117]
| v1 | v2 | v3 | v4 | |
|---|---|---|---|---|
| 1 | 2 | 3 | 6 | |
| 2 | 4 | 2 | 8 | |
[0118] 5. The Concatenate Statement
[0119] The concatenate statement has the following syntax:
-
- [0120] CONCATENATE dataset1 dataset2 . . .
[0121] The output of this statement is the result of reading each of the specified datasets and writing all their records to a single output dataset. The order of the output data does not matter. However, the list of fields in the datasets must match. In the illustrated embodiment, the CONCATENATE operation does not obey the default input rules used by other processing statements (i.e., it does not take, as input, the output of the previous statement).
[0122] 6. The Aggregate Statement
[0123] The aggregate statement is used to compute the following aggregates over sets of records: SUM, MIN (minimum), MAX (maximum). The aggregate statement has the following syntax:
-
- [0124] AGGREGATE field=aggop expression, field=aggop expression . . . [BY key, key . . . ]
[0125] An “aggregation operation” (aggop) consists of one of the keywords SUM, MIN, MAX. If no BY clause is specified, then the output of the AGGREGATE operation is a single record containing the sums/minima/maxima (as appropriate) of the indicated expressions, computed across the entire dataset. For example, suppose the following dataset is to be processed:
-
- [0126] value
- [0127] 1
- [0128] 2
- [0129] 3
- [0130] 4
- [0126] value
[0131] Here is a sample script:
[0132] INPUT indata input.data
[0133] AGGREGATE v1=MIN value, v2=MAX value, v3=SUM value
[0134] OUTPUT outdata output.data
[0135] This produces the following output:
[0136]
| v1 | v2 | v3 |
|---|---|---|
| 1 | 4 | 10 |
[0137] If the BY clause is specified, then the data will be divided into subsets, with each subset having identical values for all the keys specified in the BY clause. The aggregates will be computed for each such subset. The keys in the BY clause will be put at the front of each output record. For example, suppose the following dataset is to be processed:
[0138]
| k1 | k2 | value |
|---|---|---|
| 1 | 2 | 7 |
| 3 | 4 | 1 |
| 3 | 4 | 2 |
| 3 | 4 | 3 |
[0139] Here is a sample script:
[0140] INPUT indata input.data
[0141] AGGREGATE v1=MIN value, v2=MAX value, v3=SUM value BY k1, k2
[0142] OUTPUT outdata output.data
[0143] This produces the following output:
[0144]
| k1 | k2 | v1 | v2 | v3 |
|---|---|---|---|---|
| 1 | 2 | 7 | 7 | 7 |
| 3 | 4 | 1 | 3 | 6 |
[0145] 7. The Analyze Statement
[0146] The analyze statement is used to invoke an algorithm which computes a single integer value based on a set of records. As with aggregate, the analyze statement takes an optional BY clause. The analyze statement is included to illustrate the measures which may be taken in cases where one or more statements cannot be parallelized.
-
- [0147] ANALYZE [BY key, key . . . ];
Illustrative Example of a Parallel Runtime System
[0148] In order to run the example application in parallel, it is necessary to employ a “parallel runtime system.” This is a software system which allows programs to be simultaneously run on multiple processors. While the methods described in this disclosure are not specific to any particular parallel runtime system, a simple runtime system will be described for purposes of illustration. The sample runtime system has four statements: run, simple-partition, hash-partition, and gather. The sample runtime system uses data in the same format as used by the analyze system.
[0149] 1. The Run Statement
[0150] The run statement has the form:
[0151] run count program argument1 argument2
[0152] The run statement invokes count instances of the specified program, passing the specified arguments on the command line to the program instances. For example, the statement run 3 myprogram arg1 would run three instances of myprogram in parallel, providing each instance with the command line parameter arg1.
[0153] Any of the arguments may optionally consist of a list of count semicolon-separated elements. For example, the argument a; b; c would be interpreted as a list of three elements, a, b, and c. When the program is run, the nth invocation of each program will be called with the nth element of each such list. For example, the statement run 2 myprogram a1; a2 b1; b2 will run two instances of myprogram in parallel. The first instance will be given the arguments a1 b1, and the second will be given the arguments a2 b2.
[0154] 2. The Simple-Partition Statement
[0155] The simple-partition statement has the form:
[0156] simple-partition input output
[0157] The simple-partition statement takes records from a semicolon-separated list of input files and divides them up among a semicolon-separated list of output files. The division may be done in any matter which divides the data up more-or-less equally. For example, in round-robin partitioning, the kth input record from each input file is written to output file (k mod m), where m is the number of output files. This operation is done in parallel. For example, suppose the following two input files “in1” and “in2” are to be processed:
[0158]
| v1 | |
|---|---|
| in1: | |
| 0 | |
| 1 | |
| 2 | |
| in2: | |
| 3 | |
| 4 | |
| 5 | |
[0159] Using the statement simple-partition in1; in2 out1; out2; out3, may result in the following three output files:
[0160]
| v1 | |
|---|---|
| out1: | |
| 0 | |
| 3 | |
| out2: | |
| 1 | |
| 4 | |
| out3: | |
| 2 | |
| 5 | |
[0161] 3. The Hash-Partition Statement
[0162] The hash-partition statement has the form:
[0163] hash-partition key input output
[0164] The hash partition statement reads records from a semicolon-separated list of input files and divides them up among a semicolon-separated list of output files. The statement requires a semicolon-separated list of key fields to be specified. For each input record, the hash partition operation will compute a “hash function” based on the specified key-values and use this function to determine the output file to which the record will be written. For example, the hash function could be computed as (k mod m)+1, where k is the sum of the values of the key fields and m is the number of output files. When this is done, all records having a given key-value will end up in the same output file. This operation is done in parallel. For example, suppose, suppose two input files “in1” and “in2” are to be processed
[0165]
| v1 | v2 | |
|---|---|---|
| in1: | ||
| 0 | 0 | |
| 0 | 1 | |
| 2 | 2 | |
| in2: | ||
| 0 | 3 | |
| 1 | 4 | |
| 2 | 5 | |
[0166] Using the statement hash-partition v1 in1; in2 out1; out2; out3 results in the following three output files:
[0167]
| v1 | v2 | |
|---|---|---|
| out1: | ||
| 0 | 0 | |
| 0 | 1 | |
| 0 | 3 | |
| out2: | ||
| 1 | 4 | |
| out3: | ||
| 2 | 2 | |
| 2 | 5 | |
[0168] 4. The Gather Statement
[0169] The gather statement has the form:
[0170] gather input output
[0171] The input is a semicolon-separated list of files, and the output is a single file. The records in the input file are combined into a single output file. This operation is done in parallel.
Preferred Embodiment of the Invention
[0172] The following subsections describe the preferred embodiment of the “analyze script” 2 steps set forth in FIG. 2
[0173] 1. Step 101—Dividing into Statements
[0174] Referring again to FIG. 1 and FIG. 2 , Step 101 divides the original script 1 into a sequence of statements 102. This is primarily a matter of parsing the original script and producing a “parse tree.” Methods for parsing computer languages are extremely well known; in most cases, all that is required is to write a “grammar” and process that grammar with a “parser generator” such as “yacc”. The result will be a program to perform the parsing.
[0175] FIG. 5 shows an example of an initial script 1 and a representation of the sequence of statements 102 it contains. These statements are categorized as datasets 201, 202, 208 and processing Steps 203, 205, 207. For convenience sake, textual identifiers (e.g., “Step1”) have been added to the statements.
[0176] 2. Step 103—Constructing a Serial Dataflow Graph
[0177] Step 103 is the construction of a serial dataflow graph 104. This is done by analyzing the sequence of statements 102. The goal is to produce a set of nodes representing datasets, processing steps, and intermediate results, and to produce a set of edges indicating the datasets/temporary results which are read or written in each processing step.
[0178] In this illustration, the serial dataflow graph 104 will be represented by three tables: a dataset table 601, a processing step table 602, and a dataset access table 603 (representing dataset access by the processing steps). FIG. 6 is a diagram showing examples of dataset table, processing step, and dataset access tables.
[0179] In the illustrated embodiment, each entry in the dataset table 601 consists of:
-
- [0180] A name for each dataset.
- [0181] The class of the dataset (e.g., input, output, temporary).
- [0182] An indication as to the location of the data (e.g., a filename).
- [0183] An indication of whether the dataset was explicitly present in the original script.
- [0184] Any other information present in the original script.
[0185] In the illustrated embodiment, each entry in the processing step table 602 consists of:
-
- [0186] A name for each processing step.
- [0187] The operation being performed.
- [0188] Any parameters or other information supplied in the script (e.g., aggregate expressions, any BY clauses).
[0189] In the illustrated embodiment, each entry in the dataset access table 603 consists of:
-
- [0190] The name of a processing step.
- [0191] The name of a dataset which is accessed by that processing step.
- [0192] The direction of the access (e.g., input vs. output).
- [0193] An indication as to the role of the dataset. For example, a processing step might read two inputs “old” and “new” and write two outputs “output” and “errors.” Most processing steps will read from a single input (e.g., “in”) and write to a single output (e.g., “out”).
[0194] FIG. 7 is a flowchart showing an example of converting a sequence of steps into a serial dataflow graph. In the preferred embodiment, this method includes the following steps.
-
- [0195] Step 500: Create initially empty tables for datasets 601, processing steps 602, and dataset accesses 603 (see
FIG. 6 also). - [0196] Step 501: Scan the statements 102 and create an entry in the dataset table 601 for each dataset 201, 202, 208 and global variable identified in the statements 102. Each entry is constructed by extracting the name of the global variable or dataset (plus additional dataset-specific information from the dataset statement) and noting that the dataset or global variable was explicitly present in the original script.
- [0197] Step 502: Determine whether any processing Steps 203, 205, 207 have not yet been analyzed and added to the processing step table 602. If all processing steps have been analyzed, the analysis is done (Step 512).
- [0198] Step 503: Select the next unanalyzed processing step.
- [0199] Step 504: Create an entry in the processing step table 602 for each such processing step. This entry should contain a name for the processing step. These names may be automatically generated, e.g., by generating a sequence of “step numbers.” Each entry should also include any parameters extracted from the processing step statement.
- [0200] Step 505: Determine which datasets 201, 202, 208 are explicitly referenced by the current processing step, and create one entry in the dataset access table 603 for each such reference.
- [0201] Step 506: Determine whether the current processing step implicitly references an existing dataset. If so, loop as follows until each reference to an implicit input is processed:
- [0202] Step 507: Examine the context of the processing step to determine which dataset is implicitly referenced.
- [0203] Step 508: Create an entry in the dataset access table 603, with the “processing step” being the current processing step and the “dataset” being the implicitly referenced dataset. In almost all cases, this form of implicit reference will be to an “implicit input”.
- [0204] Step 509: Determine whether the current processing step implicitly creates a new dataset. If so, loop as follows until each reference to a new dataset is processed:
- [0205] Step 510: Create an entry in the dataset table 601 for a new implicit dataset. This involves creating a new dataset identifier and noting that the dataset was not explicitly created.
- [0206] Step 511: Create an entry in the dataset access table 603, with the “processing step” being the current processing step, and the “dataset” being the newly created intermediate result dataset. In almost all cases, this form of implicit reference will be to an “implicit output”.
- [0195] Step 500: Create initially empty tables for datasets 601, processing steps 602, and dataset accesses 603 (see
[0207] The exact method for resolution of implicit dataset references (Steps 507 and 510) is dependent on the semantics of the scripting language being processed. However, the rules for this resolution are typically quite simple, and the implementation of such resolution strategies should be a matter of routine programming. The rules used for implicit dataset resolution in the analyze scripting language described above are representative of one way to perform this task:
-
- [0208] If a processing step requires input data, and no input dataset is specified, and the previous statement is a dataset, then the previous statement's dataset is implicitly referenced as the current processing step's input.
- [0209] If a processing step requires input data, and no input dataset is specified, and the previous statement is a processing step, then the output of the previous processing step is implicitly referenced as the current processing step's input.
- [0210] If a processing step produces output, and no output dataset is specified, and the next statement is a dataset, then the next statement's dataset is implicitly referenced as the current processing step's output.
- [0211] If a processing step produces output, and no output is specified, and the next statement is a processing step, then a new intermediate dataset is implicitly created and implicitly referenced as the current processing step's output.
[0212] As an example of resolution of implicit references, see FIG. 6 . The sample script 1 shown in FIG. 6 contains three processing Steps 203, 205, 207, shown in the processing step table 602. For this example, the explicit and implicit dataset references are as follows:
-
- [0213] The first processing step 203 is the “CONCATENATE” operation, which explicitly reads from the datasets indata1 201 and indata2 202. No output dataset is specified, so the processing step implicitly creates and references an intermediate result “temp1” 204 in the dataset table 601.
- [0214] The second processing step 205 is the “AGGREGATE” operation. No input is specified, so the operation implicitly references the output “temp1” 204 of the previous step 203 as its input. No output is specified, so the processing step implicitly creates and references an intermediate result “temp2” 206 in the dataset table 601.
- [0215] The final processing step 207 is the “ANALYZE” operation. No input is specified, so the operation implicitly references the output “temp2” 206 of the previous step 205 as its input. No output is specified, but the next operation is the output dataset “outdata” 208, so “outdata” is implicitly referenced.
[0216] 3. Step 105—Parallelizing the Serial Dataflow Graph
[0217] a. Overview
[0218] This section will describe how, given a repertoire of methods for parallelizing some of the individual steps of the application, it is possible to automatically generate a parallel dataflow graph 106 from the serial dataflow graph 104. For this method to work, the parallelization repertoire should be encapsulated as a database, program, or algorithm which may examine a single vertex in the serial dataflow graph 104 and generate one or more vertexes and edges in the parallel dataflow graph 106. Given a suitable repertoire of parallelization methods plus representations for the serial and parallel dataflow graphs, construction of such a repertoire application method should be a matter of routine programming.
[0219] FIG. 8 is a table 900 showing a repertoire of parallelization methods. In general, each parallelization method will have an applicability test 901, a rewrite rule 902, and some notion of optimality (e.g., represented by the order in which the parallelization methods are considered). FIG. 8 is described in further detail below.
[0220] Many methods are known for parallelizing computations which might be included in the repertoire. The present invention primarily (though not exclusively) utilized one particular family of techniques which involve:
-
- [0221] Dividing the input data into multiple disjoint subsets. This is called “partitioning.” Each such subset is called a “partition.” Many forms of partitioning are known, differing in the manner in which the data is divided into subsets.
- [0222] Running multiple instances of a program, arranging for each instance to process a different partition of the data. This is called “partitioned execution.”
[0223] If the input data can be suitably partitioned, then partitioned execution will generally lead to large improvements in performance. For example, if data were partitioned 30 ways, then each instance of the processing step would process 1/30 the data, and should thus complete its work in 1/30 the time which would be required under serial execution. For further discussion of partitioning, see U.S. Pat. No. 5,819,021, issued Oct. 6, 1998, entitled OVERPARTITIONING SYSTEM AND METHOD FOR INCREASING CHECKPOINTS IN COMPONENT-BASED PARALLEL APPLICATIONS, and assigned to the assignee of the present invention. The teachings and contents of U.S. Pat. No. 5,819,021 are hereby incorporated by reference.
[0224] FIG. 9 is a flowchart showing the preferred method for parallelizing a serial dataflow graph 104. The method takes, as its input, a serial dataflow graph 104, preferably represented as dataset 601, processing step 602, and data access tables 603. The method produces, as its output, a parallel dataflow graph 106, preferably represented as a parallel dataset table 801, a parallel processing step table 802, and a parallel data access table 803. FIG. 10 is a diagram showing examples of initial parallel dataset, processing step, and data access tables. The method includes the following steps:
-
- [0225] Step 700: Initialize the parallel dataset 801, processing step 802, and data access 803 tables. This is done by copying the information contained in the serial dataset 601, processing step 602, and data access 803 tables, and initializing a “partitioning” data element. For datasets stored in normal (serial) files 201, 202, 208, the partitioning data element will be initialized to “serial”, signifying that these files are not parallel. Otherwise, the partitioning data element will be left blank, signifying that the manner of parallelization has not yet been determined.
- [0226] Step 701: The system will repeatedly look for processing steps which have not yet been processed. This may be done by scanning the processing step table 802 for steps having blank “partitioning” data elements.
- [0227] Step 707: If all steps have been parallelized, then a “partitioning conflict resolution algorithm” is invoked to ensure that data is correctly partitioned. This algorithm is discussed below. Once this has been done, parallelization is complete (Step 708).
- [0228] Step 702: If the graph contains unprocessed steps, then one step is selected (e.g., arbitrarily).
- [0229] Step 703: The parallelization repertoire table 900 will then be consulted to locate a parallelization method which is applicable to the step just selected.
- [0230] Step 705: If a parallelization method was located, then its rewrite rule 902 is applied to modify the information in the parallel dataset 801, processing step 802, and data access tables 803. Once this is done, the algorithm looks for another unprocessed element (at Step 701).
- [0231] Step 706: If no parallelization method was located, then the step's “partitioning” method is set to “serial”, indicating that the step must be run serially. Once this is done, the algorithm looks for another unprocessed element (at Step 701).
[0232] b. Example
[0233] The method just described may be applied to a serial dataflow graph in the following manner. As noted above, FIG. 10 is an example of initial parallel dataset, processing step, and dataset access tables. FIG. 11 is a diagram showing the parallel dataset, processing step, and dataset access tables of FIG. 10 after parallelization but before resolution of conflicts (see also FIGS. 6 , 8, and 9).
-
- [0234] Step 700: Initialization.
- [0235] The parallel dataset table 801 is initialized.
- [0236] The input 201, 202 and output 208 datasets are marked as “serial.”
- [0237] All other information is simply copied from serial dataset table 601.
- [0238] The contents of the serial processing step table 602 are copied to produce the parallel processing step table 802.
- [0239] The contents of the serial dataset access table 603 are copied to produce the parallel dataset access table 803.
- [0235] The parallel dataset table 801 is initialized.
- [0240] Step 701: An unprocessed step 203 (Application Step 1 in the parallel processing step table 802) is selected.
- [0241] Step 703: By reference to the parallelization repertoire table 900, it is determined that the CONCATENATE (“CONCAT”) operation 903 may be parallelized by “simple partitioning”.
- [0242] Step 705: The rewrite rule for simple partitioning performs the following actions (see
FIG. 11 ):- [0243] The processing step 203 is marked for “simple” partitioning.
- [0244] The step's inputs 220, 221 and output 222 are marked as accessing simply partitioned data.
- [0245] Step 701: Looping back, an unprocessed next step 205 (Application Step 2 in the parallel processing step table 802) is selected.
- [0246] Step 703: By reference to the parallelization repertoire table 900, it is determined that the “AGGREGATE BY” operation 906 may be parallelized by “key-based partitioning”.
- [0247] Step 705: The rewrite rule for key-based partitioning performs the following actions (see
FIG. 11 ):- [0248] The processing step 205 is marked as partitioned “by v2, v3”.
- [0249] The step's input 223 and output 224 are marked as partitioned “by v2, v3”.
- [0250] Step 701: Looping back, an unprocessed step 207 (Application Step 3 in the parallel processing step table 802) is selected.
- [0251] Step 703: By reference to the parallelization repertoire table 900, it is determined that no parallelization method has been indicated.
- [0252] Step 706: Accordingly, the processing step is marked for serial execution (see
FIG. 11 ):- [0253] The partitioning method for the processing step 207 is set to “serial”.
- [0254] The step's input 225 and output 226 have their partitioning method marked as “serial”.
- [0255] Step 701: Looping back, no more unprocessed steps are located.
- [0256] Step 707: Partitioning conflicts are resolved (see discussion immediately below). The result of this process is shown as
FIG. 11 .
- [0234] Step 700: Initialization.
[0257] c. Resolution of Partitioning Conflicts
[0258] Once all processing steps have been either parallelized or marked as serial, partitioning conflicts can be resolved (Step 707 in FIG. 9 ). In the illustrated embodiment, at the start of this algorithm, all processing steps will be labeled with a partitioning method, such as “serial”, “simple”, or “by key”. Similarly, all external datasets will be labeled with a partitioning method. Dataset accesses will also be marked with a partitioning method. At this point, the graph may contain “partitioning conflicts”. For example, there will often be mismatches between dataset access entries and the datasets they access. For example, Application Step 1 in FIG. 11 has two inputs 220, 221 which are marked for “simple” parallel partitioning, but the datasets 201, 202 they access are marked as “serial”. As another example, temporary datasets may not yet have their partitioning method filled in.
[0259] FIG. 12 is a flowchart showing a preferred method for resolving partitioning conflicts (Step 707 in FIG. 9 ):
-
- [0260] Step 1600: Determine whether there are any unprocessed steps in the graph. If not, then algorithm is done (Step 1601).
- [0261] Step 1602: Select a processing step such that all upstream steps have been processed.
- [0262] Step 1603: Determine whether the processing step has any dataset accesses which are unprocessed. If there are no such accesses, then the step is marked as processed (Step 1604) and the algorithm looks for the next step to process (at Step 1600).
- [0263] Step 1605: Select an unprocessed dataset access associated with the current processing step.
- [0264] Step 1606: Determine whether the dataset access's partitioning method matches the dataset's partitioning method. In the preferred embodiment, the following rules apply:
- [0265] If the dataset's partitioning method is blank, then there is a mismatch.
- [0266] If the dataset's partitioning method is serial, and the access's method is not serial, then there is a mismatch.
- [0267] If the dataset's partitioning method is “simple” or “by-key”, and the access's method is “serial”, then there is a mismatch.
- [0268] If the dataset's partitioning method is “simple”, and the access's method is “by-key”, then there is a mismatch.
- [0269] If the dataset's partitioning method is “by-key”, and the access's method is “by-key”, but the keys differ, then there is a mismatch.
- [0270] Otherwise the partitioning methods match, the access may be marked as processed (Step 1607) and the algorithm looks for another unprocessed dataset access (at Step 1603).
- [0271] Step 1608: If the dataset's partitioning method is blank (this happens when accessing a temporary dataset), then the dataset's partitioning method is set to be the same as the dataset access's partitioning (Step 1609), after which the access is marked as processed (Step 1607) and the algorithm looks for another unprocessed dataset access (at Step 1603).
[0272] If the dataset's partitioning method is not blank, then it is necessary to insert one or more additional processing steps (called “adapters”) to repair the partitioning conflict. An adapter may read one dataset and produce a second dataset having some desired partitioning. Further discussion of adapters is set forth in U.S. patent application Ser. No. 08/678,411, filed Jul. 2, 1996, entitled EXECUTING COMPUTATIONS EXPRESSED AS GRAPHS, and assigned to the assignee of the present invention. The teachings and contents of U.S. patent application Ser. No. 08/678,411 are hereby incorporated by reference.
[0273] The adapter which is selected depends on the partitioning required by the output dataset:
-
- [0274] The simple-partition adapter produces a parallel dataset. Its input is a serial dataset, and its output is a simply partitioned dataset.
- [0275] The gather adapter produces a serial dataset. Its input is a partitioned dataset and its output is a serial dataset.
- [0276] The hash-partition adapter produces a dataset partitioned by some set of keys. The desired keys are passed as parameters to the hash-partition operation. Its input is any dataset (serial, simply partitioned, or key-partitioned), and its output is a dataset partitioned on the specified key.
The order in which an adapter is inserted depends on the type of data access. Accordingly, the method continues as follows: - [0277] Step 1610: Determine whether the dataset access represents an input (vs. an output) of the processing step being processed.
- [0278] Step 1611: If the reference is to an input, then an adapter followed by a temporary dataset is inserted between the source dataset and the processing step. The partitioning of the adapter will match that of the source dataset, while the partitioning of the temporary dataset will match that of the dataset access.
- [0279] Step 1612: If the reference is to an output, then a temporary dataset followed by an adapter will be inserted between the processing step and the destination dataset. The partitioning of the adapter will match that of the source dataset, while the partitioning of the temporary dataset will match that of the dataset access.
- [0280] Once the adapter and temporary dataset have been inserted, the access will be marked as “processed” (Step 1607) and the algorithm will look for another unprocessed dataset access (at Step 1603).
[0281] d. Example
[0282] As noted above, FIG. 11 shows the parallel dataset, processing step, and dataset access tables of FIG. 10 after parallelization but before resolution of conflicts. FIG. 13 is a diagram showing FIG. 11 after resolution of Application Step 1 of the parallel processing step table. FIG. 14 is a diagram showing FIG. 13 after resolution of Application Step 2 of the parallel processing step table. FIG. 15 is a diagram showing FIG. 14 after resolution of Application Step 3 of the parallel processing step table. Application of the method shown in FIG. 12 results in the following process steps:
-
- [0283] Steps 1600, 1602: The algorithm determines that Application Step 1 (processing step 203) has not been processed (see
FIG. 11 ). - [0284] Steps 1603, 1604: The algorithm determines that the first input 220 of Application Step 1 has not yet been processed.
- [0285] Step 1606: The dataset 201 is marked “serial”, and the access 220 is marked “simple,” so there is a conflict.
- [0286] Step 1608: The partitioning of the dataset 201 is non-blank.
- [0287] Step 1610: The dataset access reference 220 references an input.
- [0288] Step 1611: An adapter and a temporary dataset are inserted between the input and the processing step.
- [0289] A simple-partition adapter Application Step 1a 210 is created (see
FIG. 13 ). As noted above, a partitioner produces a simply partitioned dataset, which matches the partitioning required by the dataset access reference 220 being processed. - [0290] The partitioner's partitioning is set to “serial”, to match the input 201.
- [0291] A temporary dataset “temp3” 212 is created. The temporary dataset's partitioning is set to “parallel”, to match the dataset access reference 220.
- [0292] New dataset access references 227, 228 are created to link the input 201, the adapter 210, and the temporary dataset 212. The “partitioning” attributes of the new dataset access references 227, 228 are set to match the datasets they reference (serial and simple, respectively).
- [0293] The existing dataset access reference 220 is re-targeted to refer to the temporary dataset “temp3” 212.
- [0289] A simple-partition adapter Application Step 1a 210 is created (see
- [0294] Step 1607: The dataset access reference 220 is marked as processed.
- [0295] Steps 1603, 1604, 1606, 1608, 1610, 1611; 1607: The same series of operations is repeated for the second input dataset referenced by Step 1, namely indata2. This results in the creation of a new partition adapter Application Step 1b 211, temporary dataset “temp4” 213, and dataset access references 229, 230.
- [0296] Steps 1603, 1604, 1606: The algorithm processes the output dataset reference 222 of Application Step 1 (processing step 203).
- [0297] Step 1608: The partitioning of the dataset being accessed, “temp1” 204, is blank.
- [0298] Step 1609: The partitioning of dataset “temp1” 204 is set to “parallel”, matching the partitioning of the dataset access reference 222.
- [0299] Step 1607: The dataset access reference 222 is marked as “processed”.
- [0300] Step 1603: The algorithm determines that Application Step 1 (processing step 203) has no more unprocessed accesses.
- [0301] Step 1604: The algorithm marks Application Step 1 (processing step 203) as “processed”.
- [0283] Steps 1600, 1602: The algorithm determines that Application Step 1 (processing step 203) has not been processed (see
[0302] The state of the graph at this time is show in FIG. 13 . The algorithm continues as follows:
-
- [0303] Step 1600, 1602: The algorithm next selects Application Step 2 (processing step 205) for processing.
- [0304] Step 1603, 1605, 1606, 1608, 1610: The algorithm selects Application Step 2's input 223 for processing and determines that it needs to insert an adapter and temporary dataset between the temporary dataset “temp1” 204 and the processing step 205.
- [0305] Step 1611: The adapter is inserted, as above (See
FIG. 14 ). This time, a “hash-partition” adapter is chosen, because the dataset access 223 specifies partitioning “by v2, v3”. This results in the creation of an adapter Application Step 2a 214, a temporary dataset “temp5” 215, and two dataset references 231, 232. - [0306] Steps 1607, 1603, 1605, 1606, 1608: The algorithm selects Application Step 2's output 224 for processing, and determines that the output's partitioning method is blank.
- [0307] Step 1609: The algorithm propagates partitioning method “by v2, v3” from the dataset access reference 224 to the temporary dataset “temp2” 206.
- [0308] Steps 1607, 1603, 1604: The algorithm finishes work on Application Step2.
[0309] The state of the graph at this time is shown in FIG. 14 . The algorithm continues as follows:
-
- [0310] Steps 1600, 1602: The algorithm selects Application Step 3 (processing step 207) for processing.
- [0311] Steps 1603, 1605, 1606, 1608, 1610: The algorithm selects Application Step 3's input 225 for processing and determines that it needs to insert an adapter and temporary dataset between the temporary dataset “temp2” 206 and the processing step 207.
- [0312] Step 1611: The adapter is inserted, as above (see
FIG. 15 ). This time, a “gather” adapter is chosen, because the dataset access reference 225 specifies “serial” partitioning. This results in the creation of an adapter Application Step 3a 216, a temporary dataset “temp6” 217, and two dataset references 233, 234. - [0313] Steps 1607, 1603, 1605, 1606: The algorithm selects Application Step 3's output 226 for processing, and determines that the partitioning for the dataset access reference 226 matches the partitioning of the output dataset “outdata” 208.
- [0314] Steps 1607, 1603, 1604: The algorithm marks Application Step 3's output 226 as “processed”, and determines that Application Step 3 has no further dataset accesses.
- [0315] Steps 1600, 1601: The algorithm determines that there are no unprocessed processing steps, and terminates.
[0316] The final state of the graph, now fully parallelized, is shown in FIG. 15 . This constitutes the parallelized dataflow graph 106.
[0317] 4. Step 107—Generating Script Fragments
[0318] In many cases, the original script-driven tool 6 may be used to implement some processing steps. To do this, an embodiment of the invention may optionally generate script fragments 4 for these processing steps. FIG. 16 is a flowchart showing a preferred method for generating script fragments:
-
- [0319] Step 2001: The system determines whether all steps have been completed. If so, the algorithm terminates.
- [0320] Step 2002: The system selects an unprocessed step.
- [0321] Step 2003: If the step is not to be implemented via the original tool 6, then it is marked as processed (Step 2009) and the algorithm repeats (at Step 2001). For each processing step which is to be implemented via the original tool 6, the following actions will be taken:
- [0322] Step 2004: Declarations for any inputs are generated. The declarations may make reference to information which is available at run-time. For example, the declarations may reference command-line arguments.
- [0323] Step 2005: The text of the processing step itself is generated. In many cases, the text of the processing step will be identical to that found in the original script 1.
- [0324] Step 2006: Declarations for any outputs are generated. The declarations may make reference to information which is available at run-time. For example, the declarations may reference command-line arguments.
- [0325] Step 2007: The input declarations, processing step, and output declarations are written to a file. This file is called a “script fragment” 4 and will generally contain a fragment of the original script.
FIG. 17 shows an example of a script fragment file containing several scripts. - [0326] Step 2008: The parallel processing step table 802 is modified to reference the script, and to note that the step is implemented by invoking the script-driven tool 6.
- [0327] Step 2009: The current step is marked as processed, and the algorithm repeats (at Step 2001).
[0328] For example, the application shown in FIG. 15 contains three processing steps 203, 205, 207 which require script generation. The result, shown in FIG. 17 , consists of three script fragments 2101, 2102, 2103.
-
- [0329] The first script fragment 2101, Script 1, corresponds to the first processing step 203, and declares two input datasets (indata1 and indata2) and one output dataset (outdata), plus a single processing step (the CONCATENATE operation). The names of the files used by the datasets generally will be obtained from the command line (see parameters listed in
FIG. 15 ). - [0330] The second script fragment 2102, Script 2, corresponds to the second processing step 205, and declares a single input and output (indata, outdata) and a single processing step (the AGGREGATE operation). The names of the files used by the datasets generally will be obtained from the command line.
- [0331] The third script fragment 2103, Script 3, corresponds to the third processing step 207, and declares a single input and output (indata, outdata) and a single processing step (the ANALYZE operation). The names of the files used by the datasets generally will be obtained from the command line.
- [0329] The first script fragment 2101, Script 1, corresponds to the first processing step 203, and declares two input datasets (indata1 and indata2) and one output dataset (outdata), plus a single processing step (the CONCATENATE operation). The names of the files used by the datasets generally will be obtained from the command line (see parameters listed in
[0332] References to the scripts and the analyze application are then inserted into the parallel processing step table 802. FIG. 18 is a diagram showing FIG. 15 after generation of script fragments. Note that, at this point, the parallel processing step table 802 consists entirely of constructs which the parallel infrastructure can directly execute.
[0333] 5. Step 108—Generating the Parallel Computation Specification
[0334] In some embodiments, the parallel data flow graph 106 can be executed directly, using the techniques taught in U.S. patent application Ser. No. 08/678,411. However, it is generally useful to generate a parallel computation specification that combines all datasets and parallel processing operations from the parallel dataset, processing step, and dataset access tables into one file. One form of this file may be a text file. This has an advantage when using a run-time system that accepts text file input. Accordingly, in the preferred embodiment, the final step in analyzing 2 a script is generation 108 of such a parallel computation specification.
[0335] FIG. 19 is a flowchart of one method of generating a parallel computation specification. In the preferred embodiment, this algorithm proceeds as follows:
-
- [0336] Step 2301: The system generates a specification for each temporary dataset. For example, this could be done by generating a list of file names used to store each temporary dataset. For parallel datasets, some fixed number n of files could be generated, whereas a single file could be specified for serial files.
- [0337] Step 2302: If no unprocessed steps remain, the process is done.
- [0338] Step 2303: Otherwise, the algorithm selects a next unprocessed processing step such that all upstream processing steps have been processed previously.
- [0339] Step 2304: The system generates a parallel command to run the selected processing step.
- [0340] Step 2305: The current processing step is marked as processed, and the algorithm loops to test for any unprocessed steps (at Step 2302)
[0341] FIG. 20 is a diagram showing the generation of temporary datasets. A list of two temporary files has been generated for each parallel temporary dataset 204, 206, 212, 213, 215, and a single temporary file has been generated for each serial temporary dataset 217.
[0342] FIG. 21 is a diagram showing the final parallel computation specification 3. Each processing step from the parallel processing step table 802 in FIG. 20 has been encoded as one of the four supported statements in the example parallel runtime system (i.e., run, simple-partition, hash-partition, gather). Each reference from the dataset access reference table 803 in FIG. 20 has been specified by including lists of dataset filenames on the command lines.
[0343] The parallel computation specification 3 plus the script fragments 4 are then executed by a parallel runtime system 5 which causes multiple instances of the original software tool 6 and/or supplemental programs 7 to be run in parallel. The resulting processes 6, 7 perform the same computation as was specified by the original script 1 but with substantial improvements in overall “throughput”.
Examples of Parallelization Methods
[0344] This section will briefly describe several methods of parallelization which can be used to define a parallelization repertoire table or database 900 (FIG. 8 ).
[0345] 1. Parallelization by Simple Partitioning
[0346] In many cases, it is possible to parallelize a processing step by partitioning the data and then running one instance of the processing step on each partition. This is typically helpful when (1) some operation is performed on individual records, and (2) the operation performed on one record is independent of the operation performed on any other record. As used with the present invention, this technique is referred to as “simple partitioning.” Any partitioning method may be used, preferably one in which roughly equal quantities of data will be present in each partition.
[0347] In the hypothetical analyze application described above, the CONCAT and COPY operations may be parallelized by simple partitioning (parallelization rule 903 in FIG. 8 ). FIG. 22 is a dataflow diagram showing an example of parallelizing the COPY operation. In the serial version 1001 of the operation, a serial dataset 1003 might be processed by a COPY processing step 1004, producing an output dataset 1005. In the parallel version 1002 of the COPY operation, the input dataset 1003 would be divided into N partitions 1006. N instances of the COPY operation 1007 would then be run, each accessing an input data partition 1006. The results would then be written to N output datasets 1008. Note that the output datasets 1008 constitute a partitioned representation of the output 1005 produced by the serial version of the program.
[0348] In the preferred embodiment, the rewrite rule 902 for the simple partitioning strategy generates an “after” dataflow symbol by use of heavy line weight for the “before” operation 1020 plus its inputs 1021 and outputs 1022.
[0349] 2. Parallelization by Key-Based Partitioning
[0350] Many operations may be parallelized by partitioning one or more inputs data based on a “key field.” This is typically helpful in cases where (1) some operation is performed on sets of records sharing a common value for a key, and (2) operations performed on one such set of records are independent of operations performed on a different set of records.
[0351] As used with the present invention, this technique is referred to as “key-based partitioning.” Key-based partitioning requires that data be divided into partitions, such that if two records r1 and r2 have the same values for the key k, they will end up in the same partition. For example, this may be accomplished by:
-
- [0352] Defining a hash function, that is, a numerical function ƒ which, when applied to a key value v produces a value h such that 0<h<=N. (N is the number of partitions).
- [0353] Applying that hash function ƒ to each record in the input dataset and steering those records to the correct partition according to the value of h.
[0354] In the hypothetical analyze application, the AGGREGATE and ANALYZE operations may incorporate a “BY” clause. Such cases may be parallelized using key-based partitioning (see parallelization rule 904 in FIG. 8 ). FIG. 23 is a dataflow diagram showing an example of parallelizing the AGGREGATE operation. In the serial version 1101, a serial dataset 1103 might be processed by the AGGREGATE processing step 1104 containing a BY clause, producing an output dataset 1105. In the parallel version 1102 of the AGGREGATE operation, the input dataset 1103 would be divided into N partitions 1106 by use of a hash function. N instances of the AGGREGATE operation 1107 would then be run, each accessing one partition 1106 of the input data. The results would then be written to N output datasets 1108. Note that the output datasets 1108 constitute a key-partitioned representation of the output 1105 produced by the serial version of the program.
[0355] In the preferred embodiment, the rewrite rule 902 for the key-based partitioning strategy marks the “before” processing step 1120 plus its inputs and outputs 1121, 1122 as “partitioned by key”. This is graphically indicated by the use of heavy line weight in an “after” dataflow graph symbol plus a notation as to the key.
[0356] 3. Access to Partitioned Data Files
[0357] The advantages of parallelism are by no means restricted to computation. In particular, parallelism has the potential to vastly speed up access to data. For example, if a single storage device can transfer data at a rate of 5 megabytes/second, then a collection of 10 such devices might transfer data at a rate of 50 megabytes/second. For this reason, it is advantageous to partition data across multiple storage devices.
[0358] FIG. 24 is a block diagram showing one method for storing a partitioned dataset. This method partitions the records in the dataset across multiple files, preferably arranging for each file to be stored on a different disk. The method can best be understood by comparison with the method used in serial files. In the serial case 1200, a single file 1201 is used to store a set of records 1202. This dataset is referenced by a single filename 1203. In a partitioned dataset 1204, several files 1205 are used, each of which stores a partition of the dataset 1206. In this case, a series of filenames 1207 may be used to reference the dataset. This series may preferably be represented as a single string with some delimiter character (e.g., a semicolon) used to separate the individual filenames within the list.
[0359] Allowed U.S. patent application Ser. No. 08/876,734, filed Jun. 16, 1997, entitled A PARALLEL VIRTUAL FILE SYSTEM, and assigned to the assignee of the present invention (the teachings and content of which are hereby incorporated by reference) describes an improved method for managing sets of files. Under this method 1208, a “control file” 1209 may be used to store the names 1210 of the data files 1205 comprising the partitioned dataset 1206. The partitioned dataset 1206 may then be referenced using a single filename 1211 which refers to the control file.
[0360] Support for partitioned datasets requires an entry 905 in the parallelization method repertoire table 900 having an applicability test 901 which examines the filename contained in a dataset to determine whether it refers to a partitioned dataset. The corresponding rewrite rule 902 sets the dataset's partitioning mode, e.g., to “simple” or some similar notation.
[0361] This method is unusual in that it slightly extends the functionality of the original tool 6, such that the parallel application can access partitioned data files
[0362] 4. Parallelization by Local-Global Division
[0363] Some processing steps produce output values which are computed based on the entire contents of the input datasets(s). For example, in the hypothetical analyze application, the AGGREGATE statement (not having a BY clause) may be called on to find the largest value of some field, computed across the entire input dataset. In many cases, it is possible to perform such data-set-wide computations by partitioning the input data, computing a “local result” for each partition, and computing the desired “global result” by combining the several “local results.” In most cases the amount of non-parallel work done in the “global combination” step is quite small compared to the parallel work done in the “local computation” step. Preferably, both the “local” and “global” steps will be performed by the original software tool 6. If necessary, however, one or both steps may be implemented by new, special-purpose code.
[0364] This method of parallelism is referred to as “Local-Global Division.” The exact computation performed for the local and global stages is dependent on the processing step being parallelized. For the aggregate operation in the hypothetical analyze application, the local stage consists of computing a local aggregate as specified in the original script 1, then applying the same aggregation operation globally to the results of local aggregation. FIG. 25 is a dataflow diagram of local-global parallelization. In the serial operation 1300, one might start with a serial dataset 1301 and an aggregate operation 1302 which finds the minimum value of one field and the maximum value of another 1303. The parallel version of this operation 1304 would involve dividing the input into partitions 1305, then applying one instance of the aggregate operation 1306 to each partition. This will produce the minimum and maximum values of the two fields 1307 within each partition. These local results will then be fed into a global aggregation step 1308 to compute the minimum/maximum across the entire dataset 1309.
[0365] In the preferred embodiment, the rewrite rule 902 for Local-Global Division 906 consists of:
-
- [0366] Replacing the original operation 1320 with a local operation 1323, a temporary intermediate dataset 1324, and a global operation 1325.
- [0367] Adding dataset accesses between the local operation and the intermediate dataset 1326, and between the intermediate dataset and the global operation 1327.
- [0368] Graphically marking the local operation 1323 and intermediate dataset 1324 as “partitioned” using heavy line weight.
- [0369] Marking the global operation 1325 as serial using light line weight.
- [0370] Graphically marking access references 1326, 1327 to the intermediate dataset as partitioned using heavy line weight.
- [0371] Attaching the inputs 1321 of the original operation 1320 to the local stage 1323 and graphically marking them as partitioned 1328 using heavy line weight.
- [0372] Attaching the outputs 1322 of the original operation 1320 to the global stage 1325 and graphically marking them as serial 1329 using light line weight.
[0373] 5. External Parallelism—Supplemental Programs
[0374] There may be cases where the original software tool 6 cannot be used to parallelize some processing step. In such cases it may be possible to introduce an “External Parallel” implementation of the step. An External Parallel implementation is a supplemental program which replicates some of the functionality in the original application in a way which allows the function to be parallelized. The implementation of such an External Parallelization routine depends on the nature of the operation being parallelized. This section describes the general method by which such external routines are integrated into the parallel version of an application.
[0375] For example, the hypothetical analyze application includes a “database unload” operation which cannot be parallelized by, for example, partitioning the database table being unloaded (doing so would require unacceptable modifications to the database table). This might, however, be parallelized by providing an “external parallel database unload” program. FIG. 26 is a dataflow diagram showing an example of External Parallelism. The original serial application 1400 might call for a database table 1401 to be accessed using its own “intrinsic unload” routine 1402, allowing the routine 1402 to access a set of data records 1403. A parallel implementation 1404 would take the same database table 1401 and use several instances of an “external unload” program 1405 to jointly scan the database table, such that each program produces a partition 1406 of the original table.
[0376] In the preferred embodiment, the rewrite rule 902 for External Parallelization 907, 908 consists of:
-
- [0377] Replacing the original operation 1420 with an external parallel routine 1423.
- [0378] In most cases, graphically marking the external parallel routine 1423 for partitioned execution using heavy line weight.
- [0379] In most cases, graphically marking the inputs 1421 and outputs 1422 and corresponding partitioned data access references 1424, 1425 using heavy line weight.
[0380] 6. Parallelization by Statement Decomposition
[0381] There may be cases where the original software tool 6 cannot be used to parallelize some processing step and it is not desirable or possible to use External Parallelism to parallelize the step. In such cases it may be possible to parallelize the processing step through Statement Decomposition. Statement Decomposition can be used when a processing step performs multiple independent tasks. When this is the case, a processing step can be parallelized by decomposing the original tasks of the step into separate tasks each of which then is processed in a separate step. Each of these new steps can then be processed simultaneously, effectively achieving parallel execution of the original step. The results of the decomposed steps are then concatenated together to form a serial output.
[0382] FIG. 27 is a dataflow diagram showing an example of Statement Decomposition. In the preferred embodiment, the rewrite rule 902 for parallelization by Statement Decomposition consists of:
-
- [0383] Replacing the original operation 1702 with the combination of a decomposed operation 1704, a temporary intermediate dataset 1705, and a field concatenation operation 1706. The field concatenation operation 1706 concatenates the fields of the records in the temporary intermediate dataset 1705.
- [0384] Adding dataset accesses 1707, 1708 between the decomposed operation and the intermediate dataset, and between the intermediate dataset and the concatenation operation, respectively.
- [0385] Graphically marking the decomposed operation 1704 and the intermediate dataset 1705 as “partitioned” using heavy line weight.
- [0386] Marking the concatenation operation 1706 as serial using light line weight.
- [0387] Graphically marking accesses 1707, 1708 to the intermediate dataset as partitioned using heavy line weight.
- [0388] Attaching the inputs 1701 of the original operation 1702 to the decomposed operation 1704 and graphically marking them as partitioned 1709 using heavy line weight.
- [0389] Attaching the outputs 1703 of the original operation 1702 to the concatenation operation 1706 and marked them as serial 1710 using light line weight.
Rewrite Rules Particular to Sas
[0390] While the invention has general applicability to a variety of scripting languages, the following provides some examples of how the invention may be adapted to the SAS language in particular. One of ordinary skill in the art should be able to apply the principles and examples herein to adapt other aspects of SAS for use with the present invention.
[0391] 1. PROC MEANS Rewrite Rule—Example of a Local-Global Division
[0392] The SAS System includes a MEANS procedure which cannot always be parallelized by, for example, Simple or Key-based partitioning. However, the MEANS procedure generally can be parallelized by applying a Local-Global Division rewrite rule. FIG. 28 is a dataflow diagram showing an example of a serial SAS script that uses the MEANS procedure 1505 to calculate descriptive statistics on a dataset 1501 and produce an output file 1502. A parallel implementation would take the same dataset 1501, use simple partitioning to produce a partitioned dataset 1504, and then use several instances of the SAS MEANS procedure 1505 to produce local values for the minimum, maximum, count, sum, and sum of squares values for the dataset 1506. A single instance of an external statistics merging application 1507 combines the local values to produce the global result 1502. The algorithms necessary to merge the local values 1506 and produce the global result 1502 are well known in the art.
[0393] 2. PROC FREQ Rewrite Rule—Example of Local-Global Division
[0394] The SAS System includes a FREQ (frequency) procedure which cannot always be parallelized by, for example, Simple or Key-based partitioning. However, the FREQ procedure generally can be parallelized by applying a Local-Global Division rewrite rule. FIG. 29 is a dataflow diagram showing an example of a serial SAS script that uses the FREQ procedure 1605 to calculate table driven statistics on a dataset 1601 and produce an output file 1602. A parallel implementation would take the same dataset 1601, use simple partitioning to produce a partitioned dataset 1604, and then use several instances of the SAS FREQ procedure 1605 to produce local frequency tables for the dataset 1606. A single instance the FREQ procedure 1607 combines the local values to produce the global result 1602. (In order to comply with the language requirements of the current embodiment of SAS, the single FREQ instance 1607 must contain the SAS statement “WEIGHT COUNT” in order to properly merge the local results 1606.)
[0395] 3. PROC UNIVARIATE Rewrite Rule—Example of Statement Decomposition
[0396] The SAS System includes the UNIVARIATE procedure which cannot be parallelized by, for example, Simple or Key-based partitioning. The UNIVARIATE procedure generally can be parallelized by applying a Statement Decomposition rewrite rule. FIG. 30 is a dataflow diagram showing an example of a serial SAS script that uses the UNIVARIATE procedure 1805 to calculate univariate statistics on a dataset 1801 and produce an output file 1802. A parallel implementation would take the same dataset 1801, use column partitioning to produce a partitioned dataset 1804, and then use several instances of the SAS UNIVARIATE procedure 1805, each producing univariate statistics for each variable (column partition) and creating a local dataset 1806. A single concatenation step 1807 then combines the local univariate datasets 1806 to produce the global result 1802.
[0397] 4. Datasteps Rewrite Rule—Example of Simple Partitioning or Key-Based Partitioning
[0398] The SAS System includes a procedural step called a “datastep”. In general, SAS programs are composed of a series of datasteps and SAS procedures. SAS datasteps can perform single or grouped record operations analogous to the AGGREGATE statement in the script language of the hypothetical analyze application. When a SAS datastep uses SAS datasets for input and output and does not contain a BY statement, Simple Partitioning may be used to compute the datastep in parallel. When a SAS datastep uses SAS datasets for input and output and does contain a BY statement, parallelization by Key-Based Partitioning may be used to compute the datastep in parallel. In this latter case, the key specified in the SAS BY statement is used as the key in the hash partition operation.
[0399] 5. SAS Script Fragments
[0400] Following This is an example of a SAS program and the fragments it would be broken into. Note that these fragments need to be modified to fit within the structure of the particular rewrite rule that is being applied. Additionally, references to temporary datasets (anywhere ‘one’ appears below, i.e., a dataset name that does not have a prefix from a libname statement) need to be replaced with the appropriate reference to the serial or parallel dataset created by the rewrite rule.
-
- [0401] libname ext “.”;
- [0402] data one;
- [0403] set ext.customer;
- [0404] by region;
- [0405] age=today ( )-birthdt;
- [0406] proc means data=one;
- [0407] var age;
- [0408] proc freq data=one;
- [0409] tables age*region;
- [0410] proc univariate data=one;
- [0411] var age income numkids;
- [0412] Fragment 1:
- [0413] libname ext “.”;
- [0414] data parallel.one;
- [0415] set ext.customer;
- [0416] by region;
- [0417] age=today ( )-birthdt;
- [0418] Fragment 2:
- [0419] proc means data=parallel.one;
- [0420] var age;
- [0421] Fragment 3:
- [0422] proc freq data=one;
- [0423] tables age*region;
- [0424] Fragment 4:
- [0425] proc univariate data=one;
- [0426] var age income numkids;
[0427] 6. Macros and Preprocessors
[0428] The SAS language allows users to create and use “macros” (collections of commands) for convenience. However, macros “hide” the underlying SAS commands. In order to more easily apply practical embodiments of the invention to a SAS script, all macros should be expanded to expose the original underlying commands. Since current embodiments of the SAS system do not provide tools specifically for macro expansion, alternative methods may be used. For example, in one embodiment, the expanded form of macros may be obtained by executing an original SAS program in a syntax checking mode. Current embodiments of SAS generate a log file from this activity that in essence contains all of the underlying SAS commands in expanded form. By reading and parsing the log file, a version of the “raw” SAS code can be obtained and processed through the analyzer 2 of the present invention. (Note that the log file is not legal SAS code per se and must be mapped or interpreted to legal commands, a straightforward process).
[0429] An alternative method for obtaining the expanded form of macros would be to write a macro preprocessor for the SAS macro language. Such preprocessors and methods for writing them are well-known in the art.
[0430] 7. Global SAS Data
[0431] The SAS system creates and references global data in two major areas: macro variables and formats. In both cases, creation and reference to such global data can be detected by examination of the SAS parse tree. For example, referring to FIGS. 6 and 7 , creation of global data by a SAS step can be detected while statements are being scanned 501. Any such references causes a global data entry to be created in the dataset table 601. In addition, reference to global data by a SAS step is found and noted when the dataset access table 603 is being created in Step 505. In this manner, any macro variables or SAS formats which are created will be provided to later SAS steps which require them.
Computer Embodiments
[0432] The invention may be implemented in hardware or software, or a combination of both. Unless otherwise specified, the algorithms included as part of the invention are not inherently related to any particular computer or other apparatus. In particular, various general purpose machines may be used with programs written in accordance with the teachings herein, or it may be more convenient to construct more specialized apparatus to perform the required method steps. However, preferably, the invention is implemented in one or more computer programs executing on programmable systems each comprising at least one processor, at least one data storage system (including volatile and non-volatile memory and/or storage elements), at least one input device, and at least one output device. Program code is applied to input data to perform the functions described herein and generate output information. The output information is applied to one or more output devices, in known fashion.
[0433] Each such program may be implemented in any desired computer language (including machine, assembly, high level procedural, or object oriented programming languages) to communicate with a computer system. In any case, the language may be a compiled or interpreted language.
[0434] Each such computer program is preferably stored on a storage media or device (e.g., ROM, CD-ROM, or magnetic or optical media) readable by a general or special purpose programmable computer, for configuring and operating the computer when the storage media or device is read by the computer to perform the procedures described herein. The inventive system may also be considered to be implemented as a computer-readable storage medium, configured with a computer program, where the storage medium so configured causes a computer to operate in a specific and predefined manner to perform the functions described herein.
[0435] A number of embodiments of the present invention have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope of the invention. For example, steps may be performed in different sequences and still achieve the same result. Accordingly, other embodiments are within the scope of the following claims.
Claims
What is claimed is:
1. A method for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements comprising at least processing steps and dataset definitions;
(b) constructing a serial dataflow graph from the parsed statements, the serial dataflow graph having nodes connected by directed edges, the nodes representing datasets, processing steps, and intermediate results; and
(c) constructing a parallel dataflow graph from the nodes of the serial dataflow graph such that the parallel dataflow graph may be executed by a parallel runtime system.
2. A method for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements comprising at least processing steps and dataset definitions;
(b) constructing a serial dataflow graph from the parsed statements, the serial dataflow graph having nodes connected by directed edges, the nodes representing datasets, processing steps, and intermediate results;
(c) constructing a parallel dataflow graph from the nodes of the serial dataflow graph such that the parallel dataflow graph may be executed by a parallel runtime system; and
(d) analyzing the parallel dataflow graph to generate script fragments in a form that enables the script-driven software tool to execute some of the processing steps.
3. The method of claims 1 or 2, wherein constructing the serial dataflow graph includes:
(a) constructing a serial dataset table of datasets used by the script;
(b) constructing a serial processing step table of statements performed by the script; and
(c) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table.
4. The method of claim 3, wherein constructing the parallel dataflow graph includes:
(a) constructing a parallel dataset table of datasets based on the serial dataset table;
(b) constructing a parallel processing step table of statements based on the serial processing step table;
(c) constructing a dataset access table based on the serial dataset access table; and
(d) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries.
5. The method of claim 4, further including resolving any existing partitioning conflicts in the constructed parallel dataflow graph.
6. The method of claim 4, wherein at least one pre-defined parallelization rewrite rule is an algorithm selected from the group comprising simple partitioning, key-based partitioning, local-global division, external parallelism algorithm, and statement decomposition.
8. The method of claims 1 or 2, wherein producing the parallel computation specification includes applying at least one pre-defined parallelization rewrite algorithm selected from the group comprising simple partitioning, key-based partitioning, local-global division, external parallelism algorithm, and statement decomposition.
9. A computer program, residing on a computer-readable medium, for parallelizing a computer application program based on a script of a script-driven software tool, the computer program comprising instructions for causing a computer to automatically analyze the script and produce a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements comprising at least processing steps and dataset definitions;
(b) constructing a serial dataflow graph from the parsed statements, the serial dataflow graph having nodes connected by directed edges, the nodes representing datasets, processing steps, and intermediate results; and
(c) constructing a parallel dataflow graph from the nodes of the serial dataflow graph such that the parallel dataflow graph may be executed by a parallel runtime system.
10. A computer program, residing on a computer-readable medium, for parallelizing a computer application program based on a script of a script-driven software tool, the computer program comprising instructions for causing a computer to automatically analyze the script and produce a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements comprising at least processing steps and dataset definitions;
(b) constructing a serial dataflow graph from the parsed statements, the serial dataflow graph having nodes connected by directed edges, the nodes representing datasets, processing steps, and intermediate results;
(c) constructing a parallel dataflow graph from the nodes of the serial dataflow graph such that the parallel dataflow graph may be executed by a parallel runtime system; and
(d) analyzing the parallel dataflow graph to generate script fragments in a form that enables the script-driven software tool to execute some of the processing steps.
11. The computer program of claims 9 or 10, wherein constructing the serial dataflow graph includes:
(a) constructing a serial dataset table of datasets used by the script;
(b) constructing a serial processing step table of statements performed by the script; and
(c) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table.
12. The computer program of claim 11, wherein constructing the parallel dataflow graph includes:
(a) constructing a parallel dataset table of datasets based on the serial dataset table;
(b) constructing a parallel processing step table of statements based on the serial processing step table;
(c) constructing a dataset access table based on the serial dataset access table; and
(d) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries.
13. The computer program of claim 12, further including resolving any existing partitioning conflicts in the constructed parallel dataflow graph.
14. The computer program of claim 12, wherein at least one pre-defined parallelization rewrite rule is an algorithm selected from the group comprising simple partitioning, key-based partitioning, local-global division, external parallelism algorithm, and statement decomposition.
16. The computer program of claims 9 or 10, wherein producing the parallel computation specification includes applying at least one pre-defined parallelization rewrite algorithm selected from the group comprising simple partitioning, key-based partitioning, local-global division, external parallelism algorithm, and statement decomposition.
17. A system for parallelizing a computer application program based on a script of a script-driven software tool, and for automatically analyzing the script and producing a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, including:
(a) means for parsing the script into statements comprising at least processing steps and dataset definitions;
(b) means for constructing a serial dataflow graph from the parsed statements, the serial dataflow graph having nodes connected by directed edges, the nodes representing datasets, processing steps, and intermediate results; and
(c) means for constructing a parallel dataflow graph from the nodes of the serial dataflow graph such that the parallel dataflow graph may be executed by a parallel runtime system.
18. A system for parallelizing a computer application program based on a script of a script-driven software tool, and for automatically analyzing the script and producing a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, including:
(a) means for parsing the script into statements comprising at least processing steps and dataset definitions;
(b) means for constructing a serial dataflow graph from the parsed statements, the serial dataflow graph having nodes connected by directed edges, the nodes representing datasets, processing steps, and intermediate results;
(c) means for constructing a parallel dataflow graph from the nodes of the serial dataflow graph such that the parallel dataflow graph may be executed by a parallel runtime system; and
(d) means for analyzing the parallel dataflow graph to generate script fragments in a form that enables the script-driven software tool to execute some of the processing steps.
19. The system of claims 17 or 18, wherein the means for constructing the serial dataflow graph includes means for:
(a) constructing a serial dataset table of datasets used by the script;
(b) constructing a serial processing step table of statements performed by the script; and
(c) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table.
20. The system of claim 19, wherein the means for constructing the parallel dataflow graph includes means for:
(a) constructing a parallel dataset table of datasets based on the serial dataset table;
(b) constructing a parallel processing step table of statements based on the serial processing step table;
(c) constructing a dataset access table based on the serial dataset access table; and
(d) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries.
21. The system of claim 20, further including means for resolving any existing partitioning conflicts in the constructed parallel dataflow graph.
22. The system of claim 20, wherein at least one pre-defined parallelization rewrite rule is an algorithm selected from the group comprising simple partitioning, key-based partitioning, local-global division, external parallelism algorithm, and statement decomposition.
24. The system of claims 17 or 18, wherein the means for producing the parallel computation specification includes means for applying at least one pre-defined parallelization rewrite algorithm selected from the group comprising simple partitioning, key-based partitioning, local-global division, external parallelism algorithm, and statement decomposition.
25. A method for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said constructing including
(i) constructing a serial dataset table of datasets used by the script,
(ii) constructing a serial processing step table of statements performed by the script, and
(iii) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
26. A method for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said constructing including
(i) constructing a serial dataset table of datasets used by the script;
(ii) constructing a serial processing step table of statements performed by the script; and
(iii) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
27. A method for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said constructing including
(i) constructing a parallel dataset table of datasets based on the serial dataset table;
(ii) constructing a parallel processing step table of statements based on the serial processing step table;
(iii) constructing a dataset access table based on the serial dataset access table; and
(iv) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
28. A method for parallelizing a computer application program based on a script of a script-driven software tool, comprising automatically analyzing the script and producing a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said instructing including
(i) constructing a parallel dataset table of datasets based on the serial dataset table;
(ii) constructing a parallel processing step table of statements based on the serial processing step table;
(iii) constructing a dataset access table based on the serial dataset access table; and
(iv) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
29. A computer program, residing on a computer-readable medium, for parallelizing a computer application program based on a script of a script-driven software tool, the computer program comprising instructions for causing a computer to automatically analyze the script and produce a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said constructing including
(i) constructing a serial dataset table of datasets used by the script;
(ii) constructing a serial processing step table of statements performed by the script; and
(iii) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
30. A computer program, residing on a computer-readable medium, for parallelizing a computer application program based on a script of a script-driven software tool, the computer program comprising instructions for causing a computer to automatically analyze the script and produce a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said constructing including
(i) constructing a serial dataset table of datasets used by the script;
(ii) constructing a serial processing step table of statements performed by the script; and
(iii) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
31. A computer program, residing on a computer-readable medium, for parallelizing a computer application program based on a script of a script-driven software tool, the computer program comprising instructions for causing a computer to automatically analyze the script and produce a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said constructing including
(i) constructing a parallel dataset table of datasets based on the serial dataset table;
(ii) constructing a parallel processing step table of statements based on the serial processing step table;
(iii) constructing a dataset access table based on the serial dataset access table; and
(iv) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
32. A computer program, residing on a computer-readable medium, for parallelizing a computer application program based on a script of a script-driven software tool, the computer program comprising instructions for causing a computer to automatically analyze the script and produce a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, by:
(a) parsing the script into statements;
(b) constructing a serial dataflow graph from the parsed statements, said constructing including
(i) constructing a parallel dataset table of datasets based on the serial dataset table;
(ii) constructing a parallel processing step table of statements based on the serial processing step table;
(iii) constructing a dataset access table based on the serial dataset access table; and
(iv) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries; and
(c) constructing a parallel dataflow graph from the serial dataflow graph.
33. A system for parallelizing a computer application program based on a script of a script-driven software tool, comprising means and for automatically analyzing the script and means for producing a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, including:
(a) means for parsing the script into statements;
(b) means for constructing a serial dataflow graph from the parsed statements, said means including means for
(i) constructing a serial dataset table of datasets used by the script;
(ii) constructing a serial processing step table of statements performed by the script; and
(iii) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table; and
(c) means for constructing a parallel dataflow graph from the serial dataflow graph.
34. A system for parallelizing a computer application program based on a script of a script-driven software tool, comprising means and for automatically analyzing the script and means for producing a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, including:
(a) means for parsing the script into statements;
(b) means for constructing a serial dataflow graph from the parsed statements, said means including means for
(i) constructing a serial dataset table of datasets used by the script;
(ii) constructing a serial processing step table of statements performed by the script; and
(ii) constructing a serial dataset access table indicating datasets in the dataset table used by statements in the processing step table; and
(c) means for constructing a parallel dataflow graph from the serial dataflow graph.
35. A system for parallelizing a computer application program based on a script of a script-driven software tool, comprising means and for automatically analyzing the script and means for producing a parallel computation specification based on such analysis, where such parallel computation specification provides functional equivalence to the script when executed by a parallel runtime system, including:
(a) means for parsing the script into statements;
(b) means for constructing a serial dataflow graph from the parsed statements, said means including means for
(i) constructing a parallel dataset table of datasets based on the serial dataset table;
(ii) constructing a parallel processing step table of statements based on the serial processing step table;
(iii) constructing a dataset access table based on the serial dataset access table; and
(iv) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries; and
(c) means for constructing a parallel dataflow graph from the serial dataflow graph.
36. A system for parallelizing a computer application program based on a script of a script-driven software tool, comprising means and for automatically analyzing the script and means for producing a parallel computation specification plus a script fragment set based on such analysis, where such parallel computation specification and script fragment set provides functional equivalence to the script when executed by a parallel runtime system, including:
(a) means for parsing the script into statements;
(b) means for constructing a serial dataflow graph from the parsed statements, said means including means for
(i) constructing a parallel dataset table of datasets based on the serial dataset table;
(ii) constructing a parallel processing step table of statements based on the serial processing step table;
(iii) constructing a dataset access table based on the serial dataset access table; and
(iv) determining, for each processing step identified in the parallel processing step table, if a corresponding pre-defined parallelization rewrite rule exists for such processing step, and if so, then applying the corresponding pre-defined parallelization rewrite rule to redefine associated entries in the parallel dataset table, the parallel processing step table, and the dataset access table as parallel processing entries; and if not, then defining such associated entries as serial processing entries; and
(c) means for constructing a parallel dataflow graph from the serial dataflow graph.
Patent Citations (44)
| Patent | Date | Inventor | Cited By |
|---|---|---|---|
| US5088034(A) | 1992-02-01 | Ihara et al. | Examiner |
| US5151991(A) | 1992-09-01 | Iwasawa et al. | Examiner |
| US5313584(A) | 1994-05-01 | Tickner et al. | Applicant |
| US5347639(A) | 1994-09-01 | Rechtschaffen et al. | Applicant |
| US5367619(A) | 1994-11-01 | Dipaolo et al. | Applicant |
| US5446915(A) | 1995-08-01 | Pierce | Applicant |
| US5475842(A) | 1995-12-01 | Gilbert et al. | Applicant |
| US5475843(A) | 1995-12-01 | Halviatti et al. | Examiner |
| US5574898(A) | 1996-11-01 | Leblang et al. | Examiner |
| US5600833(A) | 1997-02-01 | Senn et al. | Examiner |
| US5632022(A) | 1997-05-01 | Warren et al. | Applicant |
| US5682537(A) | 1997-10-01 | Davies et al. | Applicant |
| US5706509(A) | 1998-01-01 | Man-Hak Tso | Applicant |
| US5712971(A) | 1998-01-01 | Stanfill et al. | Examiner |
| US5734886(A) | 1998-03-01 | Grosse et al. | Applicant |
| US5768564(A) | 1998-06-01 | Andrews et al. | Examiner |
| US5799149(A) | 1998-08-01 | Brenner et al. | Examiner |
| US5819021(A) | 1998-10-01 | Stanfill et al. | Examiner |
| US5860009(A) | 1999-01-01 | Uchihira et al. | Applicant |
| US5870743(A) | 1999-02-01 | Cohen et al. | Examiner |
| US5909681(A) | 1999-06-01 | Passera et al. | Applicant |
| US5935216(A) | 1999-08-01 | Benner et al. | Applicant |
| US5956704(A) | 1999-09-01 | Gautam et al. | Examiner |
| US5983228(A) | 1999-11-01 | Kobayashi et al. | Applicant |
| US5999729(A) | 1999-12-01 | Tabloski, Jr. et al. | Applicant |
| US6031993(A) | 2000-02-01 | Andrews et al. | Examiner |
| US6077313(A) | 2000-06-01 | Ruf | Examiner |
| US6182061(B1) | 2001-01-01 | Matsuzawa et al. | Applicant |
| US6205465(B1) | 2001-03-01 | Schoening et al. | Examiner |
| US6253371(B1) | 2001-06-01 | Iwasawa et al. | Examiner |
| US6266804(B1) | 2001-07-01 | Isman | Examiner |
| US6295518(B1) | 2001-09-01 | McLain et al. | Examiner |
| US6311265(B1) | 2001-10-01 | Beckerle et al. | Applicant |
| US6330008(B1) | 2001-12-01 | Razdow et al. | Applicant |
| US6415286(B1) | 2002-07-01 | Passera et al. | Applicant |
| CA2259362 | 1998-01-01 | Applicant | |
| EP421408 | 1991-04-01 | Applicant | |
| JP3-126169 | 1991-05-01 | Applicant | |
| JP8-16429 | 1996-01-01 | Applicant | |
| JP10-232875 | 1998-09-01 | Applicant | |
| JP10-340276 | 1998-12-01 | Applicant | |
| JP11-514116 | 1999-11-01 | Applicant | |
| JP2000148699 | 2000-05-01 | Applicant | |
| WO97/23826 | 1997-07-01 | Applicant |
Non-Patent Literature (13)
- A User Level Program Transformation Tool, Francois Bodin et al., ACM 1998, 180-187.Examiner
- Torrent Technical White Paper, “ORCHESTRATOR for the SAS System—Delivering Scalability and Performance to SAS Applications”, pp. 1-30.Applicant
- Afrati et al., “Performance Considerations on a Random Graph Model for Parellel Processing”, Informatique Theorique et Applications, vol. 27, No. 4, pp: 367-388, (1993).Applicant
- Apers et al., “PRISMA/DB: A Parallel, Main Memory Relational DBMS”, IEEE, pp: 541-554 (1992).Applicant
- Boral et al., “Prototyping Bubba: A Highly Parallel Database System”, IEEE, vol. 2, No. 1 pp: 4-24, (Mar. 1990).Applicant
- Braun, Peter, “Parallel Program Debugging Using Scalable Visualization”,IEEE, pp: 699-708 (1995).Applicant
- DeWitt et al., “The Gamma Database Machine Project”, IEEE, vol. 2, No. 1, pp: 44-62, (Mar. 1990).Applicant
- Graefe et al., “Encapsulation of Parellelism and Architecture Independence in Extensible Database Query Execution”, IEEE, vol. 19, No. 8, pp: 749-764 (Aug. 1993).Applicant
- Graefe, Goetze “Volcano—An Extensible and Parellel Query Evaluation System”, IEEE, vol. 6, No. 1, pp: 120-135 (Feb. 1994).Applicant
- Li et al., “Load Balancing Problems for Multiclass Jobs in Distributed/Parellel Computer Systems”, IEEE, vol. 47, No. 3, pp: 322-332, (Mar. 1998).Applicant
- Rim et al., “An Efficient Dynamic Load Balancing Using the Dimension Exchange Method for Balancing Quantized Loads on Hypercube Multiprocessors”, IEEE, pp: 708-712 (1999).Applicant
- Stanfill, Craig, “Massively Parallel Information Retrieval for Wide Area Information Servers”, IEEE, pp: 679-682 (1991).Applicant
- Stanfill, Craig, “The Marriage of Parallel Computing and Information Retrieval”, IEEE, (2003).Applicant