# Patent

## Title
Optimizations using a BPEL compiler

## Abstract

Various arrangements for reducing a size of a Business Process Execution Language (BPEL) data blob for storage may be presented. One or more dehydration points within compiled BPEL code may be identified. A liveness analysis for the one or more dehydration points may be performed. At each of the one or more dehydration points, one or more live variables from a set of variables may be identified. An optimization data structure may be created for each dehydration point identifies the one or more live variables.

## Background
CROSS REFERENCES
This Application claims priority to Provisional Application No. 61/541,300, filed Sep. 30, 2011, entitled “Optimizations Using a BPEL Compiler.” The said provisional application is incorporated in its entirety for all purposes.


BACKGROUND
Business Process Execution Language (BPEL) may be used for defining how business processes interact with web services. In some instances, when a BPEL process is being executed, interaction with an external web service is necessary. Waiting for a response from the external web service or some other entity may take a significant amount of time, such as several minutes, hours, or days. When a response is required, rather than maintaining the BPEL process as active, it may be more efficient to temporarily suspend processing of the BPEL process to free memory and/or processing resources.
To suspend the BPEL process, dehydration may be performed. Dehydration may involve data related to the BPEL process being stored in a data storage structure, such as a database residing on a hard drive, until processing is to resume. Such dehydration may involve all values of variables of the BPEL process being stored and an indication of where in the BPEL code the BPEL process was suspended. This data may be stored as a data “blob” in the data storage structure. Once a response is received from the external web service, the blob may be “rehydrated,” such that the values of variables are reloaded from the data storage structure, and the BPEL process can continue being processed.
While temporarily storing variables and other data related to the BPEL process may be more efficient to free memory and/or processing resources, the amount of space necessary to store all of the variables related to the BPEL process may be significant. For example, some variables which may be based on XML may be many kilobytes or possibly megabytes in size. As such, dehydrating all of the variables of a BPEL process may require many megabytes of storage space. If a large number of BPEL processes are run concurrently, the amount of space necessary to store multiple dehydrated BPEL processes concurrently may be significant. Further, dehydrated BPEL processes that are no longer going to be rehydrated may remain stored until manually purged by a user. As this number of dehydrated BPEL processes grow, the amount of storage space consumed also grows.
SUMMARY
In some embodiments, a method for reducing a size of a Business Process Execution Language (BPEL) data blob for storage is presented. The method may include identifying, by a computer system, one or more dehydration points within BPEL code. The method may include performing, by the computer system, a liveness analysis for the one or more dehydration points. The method may include identifying, by the computer system, at each of the one or more dehydration points, one or more live variables from a set of variables. The method may include creating, by the computer system, an optimization data structure that for each dehydration point identifies the one or more live variables.
Embodiments of such a method may include one or more of the following: At runtime, the optimization data structure may be checked when the one or more dehydration points are reached such that the one or more live variables of the set of variables are stored within the BPEL data blob and one or more not-live variables of the set of variables are not stored within the BPEL data blob. The method may include compiling, by the computer system, the BPEL code using a BPEL compiler configured to perform the liveness analysis, thereby creating compiled BPEL code. The method may include executing, by the computer system, a BPEL process using the compiled BPEL code. The method may include dehydrating, by the computer system, the BPEL process at a dehydration point during execution of the BPEL process using the compiled BPEL code. The method may include identifying, by the computer system, using the optimization data structure, the one or more live variables for the dehydration point. The method may include creating, by the computer system, the BPEL data blob that comprises the one or more live variables of the set of variables, but does not comprise not-live variables of the set of variables. The method may include storing, by the computer system, the BPEL data blob. The BPEL data blob may be smaller than if the BPEL data blob contained live and not-live variables. The optimization data structure may be a file that comprises an indication of each variable that is live at each dehydration point of the compiled BPEL code. The optimization data structure may be a file that comprises an indication of each variable that is live at each dehydration point of the compiled BPEL code. At least some variables of the set of variables may be XML variables.
In some embodiments, a computer program residing on a non-transitory processor-readable medium for reducing a size of a business-process data blob for storage is presented. The computer program may include computer-readable instructions configured to cause a computer to identify one or more dehydration points within code. The computer-readable instructions may be further configured to cause the computer to perform a liveness analysis for the one or more dehydration points. The computer-readable instructions may be further configured to cause the computer to identify at each of the one or more dehydration points, one or more live variables from a set of variables. The computer-readable instructions may be further configured to cause the computer to create an optimization data structure that for each dehydration point identifies the one or more live variables.
Embodiments of such a method may include one or more of the following: At runtime, the optimization data structure may be checked when the one or more dehydration points are reached such that the one or more live variables of the set of variables are stored within the business-process data blob and one or more not-live variables of the set of variables are not stored within the business-process data blob. The computer-readable instructions may be further configured to cause the computer to compile the code using a compiler configured to perform the liveness analysis, thereby creating compiled code. The computer-readable instructions may be further configured to cause the computer to execute a process using the compiled code. The computer-readable instructions may be further configured to cause the computer to dehydrate the process at a dehydration point during execution of the process using the compiled code. The computer-readable instructions may be further configured to cause the computer to identify, using the optimization data structure, the one or more live variables for the dehydration point. The computer-readable instructions may be further configured to cause the computer to create the business-process data blob that comprises the one or more live variables of the set of variables, but does not comprise not-live variables of the set of variables. The computer-readable instructions may be further configured to cause the computer to store the business-process data blob. The business-process data blob may be smaller than if the business-process data blob contained live and not-live variables. The optimization data structure may be a file that comprises an indication of each variable that is live at each dehydration point of the compiled code. The optimization data structure may be a file that comprises an indication of each variable that is live at each dehydration point of the compiled code. At least some variables of the set of variables may be XML variables. The code may be a business process execution language (BPEL) code.
In some embodiments, a method for optimizing a Business Process Execution Language (BPEL) code for execution is presented. The method may include compiling, by a computer system, the BPEL code using a BPEL compiler configured to perform an optimization. The method may include identifying, by the computer system, one or more points within the BPEL code that are eligible for the optimization. The method may include creating, by the computer system, optimized executable BPEL code based on the BPEL code, wherein the optimized executable BPEL code based on the BPEL code has the optimization.



BRIEF DESCRIPTION OF THE DRAWINGS
A further understanding of the nature and advantages of various embodiments may be realized by reference to the following figures. In the appended figures, similar components or features may have the same reference label. Further, various components of the same type may be distinguished by following the reference label by a dash and a second label that distinguishes among the similar components. If only the first reference label is used in the specification, the description is applicable to any one of the similar components having the same first reference label irrespective of the second reference label.
FIG. 1 illustrates an embodiment of a system that includes a BPEL composite application.
FIG. 2 illustrates an embodiment of a system for compiling a BPEL composite application and creating an optimization data structure.
FIG. 3 illustrates an embodiment of a system configured to dehydrate a BPEL process using an optimization data structure.
FIG. 4 illustrates an embodiment of a system configured to rehydrate a BPEL process.
FIG. 5 illustrates an embodiment of a method for creating an optimization data structure to be used for reducing the size of a BPEL data blob for storage.
FIG. 6 illustrates another embodiment of a method for creating an optimization data structure to be used for reducing the size of a BPEL data blob for storage.
FIG. 7 illustrates an embodiment of a method for dehydration of a BPEL runtime process using an optimization data structure.
FIG. 8 illustrates another embodiment of a method for dehydration of a BPEL runtime process using an optimization data structure.
FIG. 9 illustrates an embodiment of a method for optimizing BPEL code.
FIG. 10 illustrates an embodiment of a computer system.



DETAILED DESCRIPTION
Rather than storing the values of all variables when a BPEL process is dehydrated, only variables that have been identified as live may have their value stored. Such live variables may be read following rehydration of the BPEL process. Conversely, following rehydration, a variable that is not read before it is written to (as such, the value of the variable at dehydration does not need to be stored because it is not read before being overwritten), is not live. A significant number of variables may be present in a BPEL process that are stored during dehydration that are superfluous because the variables are not live. Since such variables are not needed to be stored when the process is dehydrated, storage of such variables can waste storage resources. If many BPEL processes are running concurrently, and thus, may be dehydrated concurrently, a significant amount of storage space may be devoted to values of variables that are not needed.
A liveness analysis, also referred to as a live variable analysis, may be performed on the code of the BPEL process to determine which variables are live at various points (that is, variables which may be read before the next write to the variable), and which variables are not live at the points (variables that are not read before they are written to or are not used again). Such a liveness analysis may be performed at the time the code of the BPEL process is compiled. The points evaluated within the code may be points where dehydration is expected to occur. As such, a liveness analysis may be used at the time BPEL code is compiled to determine which variables will be live and which variables will not be live at each dehydration point of the compiled BPEL code. (To be clear, a particular variable may be live at one dehydration point but not live at another dehydration point.)
An optimization data structure (e.g., a file, table, database) may be created based on the liveness analysis. The optimization data structure may specify which variables are live for each dehydration point. To specify which variables are live, indications of the live and/or not live variables may be stored (for example, the optimization data structure may only indicate live variables for a dehydration point, with variables not indicated being considered not live). When a BPEL (runtime) process reaches a dehydration point, it may be configured (through how it was compiled) such that it uses the optimization data structure to determine which variables should be retained during dehydration and which variables should be discarded. In some embodiments, the optimization data structure may indicate each variable that should be stored for each dehydration point. For example, if a first dehydration point is reached when creating a data blob (as used within this document, a data blob may refer to structured or unstructured data stored within a database or other storage structure) for storage, the BPEL process may examine the optimization data structure to determine which variables are to be retained at the first dehydration point. Only variables identified as live at the first dehydration point may be retained for storage within the data blob. The data blob may then be stored in a data structure until the BPEL process is to continue being processed.
The size of the data blob having only live variables that is temporarily stored is smaller than the size of the data blob if live and not live variables had been stored. In some instances, the size of the data blob with only live variables may be significantly smaller. For example, in a test embodiment, a data blob storing all variables was 237 kb, while when only live variables were stored within the data blob, the data blob was 42 kb, roughly a five-fold decrease in size. If many BPEL processes are dehydrated concurrently, the total storage space needed may be decreased significantly (e.g., by a factor of 5). This is especially important to consider when large numbers of processes may be dehydrated concurrently, such as thousands of concurrent BPEL processes.
While this document focuses on the BPEL programming language, it should be understood that similar systems and methods may be applied to other business-process programming languages, such as business-process programming languages that permit temporary dehydration of a process being executed. More generally, such principles may be applied to other programming arrangements that permits dehydration and rehydration of a process being executed.
FIG. 1 illustrates an embodiment of a system 100 that includes a BPEL composite application 120 that has been compiled into JAVA code and is executed as a BPEL runtime process. System 100 includes: web service clients 110, BPEL composite application 120, external applications 130 and 140, and networks 150. Web service clients 110 may be entities (e.g., remote computer systems) that request a web service from BPEL composite application 120. Web service clients 110 may be operated by users. Web service clients 110 may communicate with BPEL composite application 120 via network 150-1. While system 100 is illustrated as having three web service clients (110-1, 110-2, and 110-3), more or fewer web service clients may be present. For example, BPEL composite application 120 may be executed for one web service client, or tens, hundreds, or thousands of web service clients.
Network 150-1 may represent one or more public and/or private networks. Network 150-1 may represent the Internet. As such, network 150-1 may allow web service clients 110 to communicate with BPEL composite application 120. In some embodiments, one or more of web service clients 110 may communicate with BPEL composite application 120 without using network 150-1.
BPEL composite application 120 may represent a process-oriented composite application created using BPEL. Instances of BPEL composite application 120 may be executed as one or more runtime processes (not illustrated). Processes based on BPEL composite application 120 may be executed by one or more computer systems. For example, each web service client of web service clients 110 may interact with a process being executed that is based on BPEL composite application 120. As such, different processes may represent different instantiations of BPEL composite application 120. In some embodiments, BPEL may be used as part of ORACLE's Service Oriented Architecture (SOA) for designing, deploying, and managing composite applications. A process-oriented composite application may include various component applications (in system 100, component applications 121, 122, 123, 124, and 125 are present) to provide an output or result to some external application or to a web service client. Each component application may perform one or more particular functions, with the output of one component application serving as an input to one or more other component applications that are linked. Such an arrangement may allow for a designer to program in a declarative nature, that is, allowing the designer to specify what outputs the composite application should accomplish, but not how it should accomplish generating those outputs on the code level. For example, for a designer to create a BPEL composite application, the designer may use a graphical user interface to interconnect a series of component applications in a desired order. The resulting composite application may then use this combination and order of component applications to provide an output.
A process-oriented composite application may process threads for many different web service clients simultaneously or near-simultaneously (this may also be referred to as multiple processes of the process-oriented composite application being executed simultaneously or near-simultaneously). As such, BPEL composite application 120 may have multiple associated BPEL processes (also referred to as BPEL runtime processes) being executed at the same time. For example, component application 122 may be being executed as part of a first BPEL process in relation to web service client 110-1, while component application 124 is being executed as part of a second BPEL process in relation to web service client 110-2. Further, a single component application may be executed on behalf of multiple web service clients. For example, component application 123 may be executed as part of the first and second processes in relation to web service client 110-1 and web service client 110-3 at the same time. In practice, if a composite application is serving as a web service for a large number of web service clients, each component application may be being executed as part of BPEL processes linked with tens or hundreds of web service clients at the same time.
The processing of a request received from a web service client of web service clients 110 by a BPEL process performing BPEL composite application 120 may result in the component applications being performed in a set order. When a request is received by a BPEL process performing BPEL composite application 120 from a web service of web service clients 110, an instance of component application 121 may initially process the request. After the instance of component application 121 has performed one or more functions, the instance of component application 121 may transmit data to an instance of component application 122. The instance of component application 122 may perform predefined functions different from the functions performed by the instance of component application 121. Following processing the data received from the instance of component application 121, the instance of component application 122 may forward data to the instance of component application 123. The instance of component application 123 may interact with an external application, such as external application 130. External application 130 may be operated on behalf of the same entity or a different entity from the entity that operates BPEL composite application 120. For example, external application 130 may be operated by a financial institution, another company, a different department, etc. For the instance of component application 123 to proceed, it may submit a request to external application 130 via network 150-2. The instance of component application 123 may wait until a response is received from external application 130 before any further processing of the thread. The timing of the response from external application 130 may be based on the nature of the request. For example, a database lookup by external application 130 may take a short period of time, such as less than a second. However, an approval for a loan that is to be processed by external application 130, which may require an employee of the financial institution to manually review information, may take multiple days. As such, this may be a point in a BPEL process where the process is dehydrated until a response is received, thus freeing memory and/or processing resources while waiting for a response.
Once a response is received, the instance of component application 123 may continue to process the data related to the corresponding web service client. Once the instance of component application 123 has completed its function, data may be passed to an instance of component application 124. As an example, the instance of component application 124 may require additional information to be provided by the corresponding web service client. A request may be sent to the appropriate web service client. Again, processing of a composite application in relation to the web service client may halt until a response is received, possibly for a short period of time, such as 300 milliseconds, or possibly multiple days or even weeks. This may be another point where the BPEL process is dehydrated until a response is received in order to free processing and/or memory resources. Once the instance of component application 124 has completed processing data related to the request received from the web service client, an instance of component application 125 may be processed.
The order of processing instances of component application 121, followed, in order, by component application 122, component application 123, component application 124, and component application 125 may be set, as coded in BPEL by the designer of BPEL composite application 120. As such, every initial request received from a web service client may be handled in the same manner: processed, in order, by component applications 121 through 125.
Following the instance of component application 125 processing the data related to the web service client passed by the instance of component application 124, a final output may be routed to an external application, such as external application 140, or may be routed back to the web service client that initiated the processing of the instance of BPEL composite application 120 being executed as a BPEL process. If routed to external application 140, external application 140 may perform some level of processing on the data received from component application 125. External application 140 may then route a result to the appropriate web service of web service clients 110 via network 150-1. Alternatively, some other application or web service client may receive the output of BPEL composite application 120.
The process of performing the web service process for a web service client may take a short period of time, such as less than a second, or may take many hours or days to complete. If a large number of web service clients are using the web service provided by instances of BPEL composite application 120 and instances of the composite application within the BPEL processes take a long period of time to execute from start to finish, the BPEL processes may result in a large amount of data being stored and/or processed for web service clients 110. For periods of inactivity during the processing of instances of BPEL composite application 120 for particular web service clients, the associated processing threads (referred to as processes or BPEL processes) may represent a waste of processing and/or memory resources. As such, it may not be efficient to maintain data linked with a BPEL process in memory local to BPEL composite application 120, especially if BPEL composite application 120 is handling requests from many web clients at once and does not have excess memory to spare. Similarly, it may not be efficient to maintain BPEL processes in memory if nothing related to the web service client currently requires active processing. As such, dehydration of such BPEL processes may be used to free processing and/or memory resources.
While BPEL composite application 120 contains five component applications, and only one external application (external application 130) is illustrated as interacting with a component application, it should be understood that BPEL composite application 120 is an example only and is not intended to be limiting in how the component applications of a composite application may interact with each other or with external applications. Embodiments of other BPEL composite applications may contain fewer or more component applications, may interact with more or fewer external applications, and/or may have a different process flow. It should be understood that FIG. 1 is intended to illustrate how BPEL composite application 120 may be executed for multiple web service clients and may involve multiple processes being executed. In FIGS. 3 and 4, a single BPEL runtime process is illustrated as being executed for a client. Such a single BPEL runtime process can represent an instance of BPEL composite application 120 (or some other composite application).
FIG. 2 illustrates an embodiment of a system 200 for compiling a BPEL composite application and creating an optimization data structure. In system 200, BPEL code 210 is used by BPEL compiler 220 to create executable BPEL composite application 120 and to create optimization data structure 230. As such, BPEL composite application 120 of system 100 may be created using BPEL compiler 220 of system 200. Each component of system 200 may represent a different module. Each module may be executed and/or stored using one or more computer systems.
BPEL code 210 may be written by a software designer (or, more generally, any user). BPEL code 210 may contain various references to external applications. At runtime, interaction with these external applications or some other external entity may take extended amounts of time. For example, some external applications may require lengthy periods of time to respond, such as several minutes, hours, days, or weeks. BPEL code 210 may be compiled by BPEL compiler 220.
BPEL compiler 220 may compile BPEL code 210 to create compiled code (which may be JAVA) that may be executed as one or more BPEL processes, such as BPEL runtime process 240. During execution, BPEL runtime process 240 may access compiled BPEL code 210. BPEL compiler 220 may be configured to identify one or more points within BPEL code 210 where dehydration of a BPEL process will occur during execution. For example, such points may occur when a response from an external source, such as an external application, is required. At such a point, the BPEL runtime process being executed may need to wait for a response from the external application. Such points may be identified as dehydration points because, from an efficiency standpoint, it may be efficient to stop executing the BPEL process and remove the BPEL process from memory and/or from having an associated processing string of the BPEL runtime process be executed by a processor. Data, such as variable values, of the BPEL runtime process may be stored in a storage structure until execution of the BPEL runtime process is to continue. At some or all of these dehydration points, BPEL compiler 220 may be configured to perform a liveness analysis.
Liveness analysis module 225 of BPEL compiler 220 may perform the liveness analysis. The following description assumes that one skilled in the art is familiar with the general concept of a liveness analysis. A liveness analysis, also referred to as live variable analysis, may be performed, possibly by a compiler during the process of compilation, to calculate at one or more points whether one or more variables may be read before being written to. If a variable may be read before the next write to the variable, the variable is considered live; if not, the variable is considered not live. Liveness analysis module 225 may analyze the state of some or all variables used within BPEL code 210 being compiled. At some or all of the points within BPEL code 210 identified as dehydration points, a determination may be made whether a variable is live or not live. A variable may be determined to be live if, following rehydration, a read of the variable is performed before a write to the variable is performed. A variable may be determined to not be live if: following rehydration, a write to the variable is performed before a read; and/or the variable is not used for the remainder of BPEL code 210.
Liveness analysis module 225 may be used to create optimization data structure 230. Optimization data structure 230 may take the form of one or more files. As an example, a single file may be created for a composite application. This file may have a file extension of, for example, .opt. This file may also have the same name as the composite application. Within optimization data structure 230, liveness analysis module 225 may indicate variables that are live for each dehydration point within BPEL code 210. As such, for each dehydration point, a listing of one or more variables that are live may be provided within optimization data structure 230. If no variables are live at a particular dehydration point, no variables may be entered for that dehydration point within optimization data structure 230.
As an example of a possible content of optimization data structure 230, the following line may be present:
compositeName.opt:201:<scopeName:xx>
This exemplary line of optimization data structure 230 may indicate that variable “xx” is live at line 201 of BPEL code 210. Additional information, such as the name of the composite and/or scope, may be present to distinguish the variable from a similarly named variable that may be present in another scope and/or composite. As those with skill in the art will recognize, scopes and other forms of BPEL notation are defined in the BPEL standard.
If a variable is not listed in optimization data structure 230 for a dehydration point, it may be determined that the variable is not live at that dehydration point (the same variable may be live or not live at other dehydration points). While in system 200, optimization data structure 230 lists live variables; in other embodiments, optimization data structure 230 may list variables that are not live. In other embodiments, optimization data structure 230 may list live and not live variables and indicate them as such. In some embodiments, multiple optimization data structures 230 may be created by liveness analysis module 225 of BPEL compiler 220.
BPEL compiler 220 may create BPEL composite application 120 based on BPEL code 210. BPEL composite application 120 may be compiled code (e.g., JAVA); the existence of the composite applications within the compiled code of BPEL composite application 120 illustrates that the code is based on the component applications used to create the compiled code. BPEL compiler 220 may compile BPEL code 210 such that BPEL runtime process 240, which is an executing instance of BPEL composite application 120, accesses optimization data structure 230 when the process is to be dehydrated. BPEL composite application 120 may be coded by BPEL compiler 220 such that if a variable is listed as live for a dehydration point within optimization data structure 230, the variable is retained in the data blob created during dehydration at that dehydration point; if a variable is not listed as live for the dehydration point within optimization data structure 230, the variable is not to be retained in the data blob created during dehydration at that dehydration point. As such, only variables that are live may be retained within the data blob. While in system 200, BPEL composite application 120 is coded such that BPEL runtime process 240 refers to optimization data structure 230 for variables to be retained when dehydrated; in other embodiments, the reverse may be possible: BPEL composite application 120 may be coded such that BPEL runtime process 240 refers to optimization data structure 230 to determine which variables are not live and may be ignored when a data blob is created at a dehydration point. The variables that are indicated as live (and thus stored) and not live (and thus not stored) may vary from dehydration point to dehydration point within the same composite application.
FIG. 3 illustrates an embodiment of a system 300 configured to dehydrate a BPEL runtime process using an optimization data structure. System 300 may comprise one or more computer systems to execute and/or store various illustrated modules. For example, BPEL runtime process 240 may be executed by one or more computer systems. Each of web service clients 110 may be a separate computer system. System 300 may represent system 100 operating in conjunction with optimization data structure 230. When the execution of the (JAVA) code of BPEL composite application 120 (that is, the BPEL runtime process 240 that is an instance of BPEL composite application 120) reaches a dehydration point (e.g., a point where a response from an external application is being waited for), BPEL runtime process 240 may be dehydrated. Such a dehydration may involve data related to BPEL runtime process 240 being stored in a storage structure, such as a database or stack.
When BPEL runtime process 240 is dehydrated, variables of BPEL runtime process 240 may be compared to indications of variables in optimization data structure 230 for the dehydration point reached by BPEL runtime process 240. Optimization data structure 230 may indicate a number of variables (e.g., 0, 1, more than one) that are live at the dehydration point reached by BPEL runtime process 240. The values of the variables identified as live as indicated by optimization data structure 230 may be maintained when BPEL runtime process 240 is dehydrated. Variables that are not live at the dehydration point reached by BPEL runtime process 240 as indicated by optimization data structure 230 may not be retained when BPEL runtime process 240 is dehydrated.
BPEL process data blob 310 may be created based on BPEL runtime process 240 and optimization data structure 230. Within BPEL process data blob 310, some number of live variables 315 may be present. BPEL process data blob 310 may contain variables that are live, but may not contain variables that are not live. As such, BPEL process data blob 310 may be smaller in size than a BPEL process data blob having both live and not live variables. The BPEL process data blob 310 may be stored using storage structure 320. Storage structure 320 may be a storage arrangement such as a table, stack, or database stored on a non-transitory computer-readable medium, such as a hard drive. BPEL process data blob 310 may remain stored in storage structure 320 until the response has been received from the external application that triggered the dehydration.
FIG. 3 illustrates a single BPEL runtime process being dehydrated. BPEL runtime process 240 may be being executed for a particular web service client, such as web service client 110-3. It should be understood that numerous BPEL runtime processes may be executed concurrently as instances of BPEL composite application 120 for multiple web service clients. As such, at any given time, one or more BPEL runtime processes may be being executed and one or more BPEL runtime processes may be dehydrated in storage structure 320.
FIG. 4 illustrates an embodiment of a system 400 rehydrating the BPEL runtime process 240 of system 300. System 400 may represent system 300 when BPEL process data blob 310 is to be rehydrated. In system 400, a trigger may have been received in relation to
BPEL runtime process 240 that initiates rehydration of BPEL process data blob 310 such that BPEL runtime process 240 may continue to be executed. For example, a response from an external application, such as external application 130, related to BPEL runtime process 240 may have been received.
To rehydrate BPEL runtime process 240, BPEL process data blob 310 may be recalled from storage structure 320. BPEL process data blob 310, which contains live variables 315 (but does not contain variables that were not indicated as live by optimization data structure 230 of FIG. 3), may be used to rehydrate the BPEL process for execution by BPEL runtime process 240. Live variables 315 may be used to rehydrate BPEL runtime process 240. During rehydration, it may not be necessary to access an optimization data structure because the values of variables present within BPEL process data blob 310 are already determined to be live during dehydration. Variables that were not live as indicated by optimization data structure 230 may not be instantiated with a particular value when BPEL runtime process 240 is rehydrated. A default value such as 0 (or an appropriate value based on the variable type) may be used for non-live variables. In some embodiments, it may be possible to skip assigning a value to the not live variables upon rehydration. Following rehydration of BPEL process data blob 310, execution of BPEL runtime process 240 may continue. At some future point, BPEL runtime process 240 may again be dehydrated. At such a second dehydration point, one or more of the same or different variables may be identified as live according to optimization data structure 230. BPEL runtime process 240 may be dehydrated and rehydrated various numbers of times as required for execution of the instance of BPEL composite application 120 as BPEL runtime process 240. Which variables are retained as live, if any, may be defined by optimization data structure 230 for each dehydration point.
While system 300 and system 400, of FIGS. 3 and 4, respectively, illustrate a single BPEL runtime process being dehydrated and rehydrated, it should be understood that many BPEL processes may be at various stages of execution, dehydration, and rehydration. For example, it may be possible that tens, hundreds, or thousands of BPEL runtime processes may be at various stages of execution, dehydration, and/or rehydration of BPEL composite application 120.
Various methods may be performed in conjunction with the previously detailed systems. FIG. 5 illustrates an embodiment of method 500 for creating an optimization data structure to be used for reducing a size of a data blob to be used for storage. Method 500 may be performed by system 200 of FIG. 2 or some other system configured to compile a BPEL composite application and creating an optimization data structure. As such, method 500 may be performed using one or more computer systems.
During the process of being compiled by a BPEL compiler (or possibly following compilation), one or more dehydration points within the BPEL code may be identified at step 510. A dehydration point may be identified based on whether a response is needed from an external application (or some other external source) before continuing to execute the compiled BPEL code for a BPEL runtime process. More generally, a dehydration point may be any point during execution of a BPEL runtime process that it may be efficient to remove the BPEL runtime process from being actively processed to a storage structure (e.g., hard drive) for a period of time. The points within BPEL code that are considered dehydration points may be predefined. For example, when an event is being waited for, such as a wait activity, an on-alarm branch of a pick activity, a receive activity, and an on-message branch of a pick activity, it may trigger dehydration. A nonidempotent activity may trigger dehydration if a retry of one or more steps is desired.
At step 520, a liveness analysis for each dehydration point identified at step 510 may be performed. The liveness analysis may be conducted by the compiler. In some embodiments, the liveness analysis may be performed by a separate entity from the compiler during compilation. Such a liveness analysis may determine at the one or more dehydration points whether some or all variables used by the BPEL runtime process during execution of the compiled BPEL code are live or not live. A live variable may be identified as a variable that, following rehydration, is read before it is written to.
At step 530, an optimization data structure may be created based on the liveness analysis of step 520. For some or all of the dehydration points identified at step 620, the optimization data structure may be configured to indicate which variables are live (and/or which variables are not live). In some embodiments, rather than indicating which variables are live, the optimization data structure may indicate which variables are not live. The optimization data structure created at step 530 may take the form of one or more computer-readable files.
While method 500 is directed to the use of BPEL, it should be understood that a similar method may be applied to other business-process directed programming languages that are configured to have processes dehydrated.
FIG. 6 illustrates an embodiment of method 600 for creating an optimization data structure to be used for reducing the size of a data blob for storage. Method 600 may be a more detailed embodiment of method 500. The method 600 may be performed by system 200 of FIG. 2. More specifically, BPEL compiler 220, as executed by one or more computer systems, may perform each step of method 600. In some embodiments, some other form of BPEL compiler may perform the steps of method 600.
At step 610, the BPEL code may start to be compiled. For example, referring to FIG. 2, BPEL code 210 may have been written by a software designer, and may be compiled by BPEL compiler 220.
During the process of being compiled by a BPEL compiler, one or more dehydration points within the BPEL code may be identified at step 620. A dehydration point may be identified based on whether a response is needed from an external application (or some other external source) before continuing to execute the compiled BPEL code for a BPEL runtime process. The points within BPEL code that are considered dehydration points may be predefined. For example, when an event is being waited for, such as a wait activity, an on-alarm branch of a pick activity, a receive activity, and an on-message branch of a pick activity, it may trigger dehydration. A nonidempotent activity may trigger dehydration if a retry of one or more steps is desired.
At step 630, a liveness analysis for each dehydration point identified at step 620 may be performed. The liveness analysis may be conducted by the compiler. In some embodiments, the liveness analysis may be performed by a separate entity from the compiler during or after compilation. Such a liveness analysis may determine at one or more dehydration points whether some or all variables used by the BPEL runtime process during execution of the compiled BPEL code are live or not live. A live variable may be identified as a variable that, following rehydration, is read before it is written to.
At step 640, an optimization data structure may be created based on the liveness analysis of step 630. For some or all of the dehydration points identified at step 620, the optimization data structure may be configured to indicate which variables are live (and/or which variables are not live). In some embodiments, rather than indicating which variables are live, the optimization data structure may indicate which variables are not live. The optimization data structure of step 640 may take the form of one or more computer-readable files.
At step 650, the BPEL code being compiled may be configured to, when executed as a BPEL runtime process, access the optimization data structure when a dehydration point has been reached. The compiled BPEL code may be further configured such that during dehydration only variables that are indicated by the optimization data structure as live at the dehydration point have their values retained. As such, variables identified in the optimization data structure as not live at the dehydration point (e.g., by not being included in the optimization file structure) will not have a value retained when a BPEL runtime process is dehydrated at the dehydration point.
At step 660, the compiled BPEL composite application may be created. One or more instances of this compiled BPEL composite application may be executed using one or more BPEL runtime processes. During execution, these BPEL runtime processes may refer back to the compiled code of the BPEL composite application.
While method 600 is directed to the use of BPEL, it should be understood that a similar method may be applied to other business-process directed programming languages that are configured to have processes dehydrated, or, more generally, other programming languages that are configured to have processes dehydrated.
FIG. 7 illustrates an embodiment of method 700 for dehydration of a BPEL runtime process using an optimization data structure. Method 700 may be performed using system 300 of FIG. 3 or some other system configured to dehydrate and rehydrate a BPEL process using an optimization data structure. More specifically, BPEL composite application 120, executed by a computer system, may perform each step. In some embodiments, some other form of BPEL composite application may perform the steps of method 700. BPEL composite application 120 may have been compiled in accordance with method 500 of FIG. 5 or method 600 of FIG. 6. In some embodiments, some other method of compiling the composite application that can perform the steps of method 700 may have been used.
When a dehydration point is reached, the optimization data structure may be accessed at step 710. The optimization data structure may be accessed in order to determine which variables should be maintained during dehydration and which variables may be discarded. Such an optimization data structure may have been created in accordance with method 500 of FIG. 5 or method 600 of FIG. 6.
At step 720, live variables at the dehydration point may be identified using the optimization data structure. The optimization data structure may indicate zero, one, or more variables that are live for each dehydration point within the BPEL composite application. As such, following step 720, zero, one, or more than one live variable may be identified by the BPEL composite application based on the optimization data structure.
At step 730, a data blob for the BPEL runtime process may be created. The data blob may contain stored data related to values of variables that were indicated as live, but not variables of variables not indicated as live. The data blob may be in some form of structured data or an unstructured binary set of data. As such, the data blob created at step 730 may contain live variables, but may not contain variables that are not live at the dehydration point as identified by the optimization data structure.
FIG. 8 illustrates an embodiment of method 800 for dehydrating a BPEL process using an optimization data structure. Method 800 may represent a more detailed embodiment of method 700. Method 800 may be performed using system 300 of FIG. 3 or some other system configured to dehydrate and rehydrate a BPEL process using an optimization data structure. More specifically, an instance of BPEL composite application 120, executed by a computer system, may perform each step. In some embodiments, some other form of BPEL composite application may perform the steps of method 800. BPEL composite application 120 may have been compiled in accordance with method 500 of FIG. 5 or method 600 of FIG. 6. In some embodiments, some other method of compiling the composite application that can perform the steps of method 800 may have been used.
At step 810, a BPEL composite application may be executed. The BPEL composite application executed at step 810 may be the BPEL composite application compiled using method 500 of FIG. 5 or method 600 of FIG. 6. Execution of the BPEL composite application may result in a BPEL runtime process based on the BPEL composite application being executed until a dehydration point is reached.
At step 820, a determination may be made to dehydrate a BPEL runtime process because a dehydration point has been reached. The dehydration point may be based on a point in the BPEL composite application where a response is required from an external application (or some other external source), and such a response may take a significant amount of time to receive.
Following determining the dehydration should occur at a dehydration point, the optimization data structure may be accessed at step 830. The optimization data structure may be accessed in order to determine which variables should be maintained during dehydration and which variables may be discarded. Such an optimization data structure may have been created in accordance with method 500 of FIG. 5.
At step 840, live variables at the dehydration point determined at step 820 may be identified using the optimization data structure. The optimization data structure may indicate zero, one, or more variables that are live for individual dehydration points within the BPEL composite application. As such, following step 840, zero, one, or more than one live variable may be identified by the BPEL composite application based on the optimization data structure.
At step 850, a data blob for the BPEL process may be created. The data blob may contain stored data related to values of variables that were indicated as live in the optimization data structure, but not values of variables not indicated as live. The data blob may be in some form of structured data or an unstructured binary set of data. As such, the data blob created at step 850 may contain live variables, but may not contain variables that are not live at the dehydration point as identified by the optimization data structure.
At step 860, the data blob created based on the BPEL process and the optimization data structure may be stored using a storage structure. Such a storage structure may be a non-transitory computer readable medium. Referring to FIG. 3, BPEL composite application 120 (being executed as BPEL runtime process 240) uses optimization data structure 230 to create BPEL process data blob 310 when a dehydration point of BPEL composite application 120 is reached. The BPEL process data blob 310 is stored in storage structure 320 until rehydration. The BPEL process data blob stored at step 860 (which may have only variables that are live) may be smaller than a BPEL process data blob that contains both live and not live variables. The live variables stored may include one or more live XML variables.
At step 870, the BPEL runtime process may be rehydrated. The BPEL runtime process may be rehydrated based on the BPEL runtime process data blob stored at step 860. Rehydration of the BPEL runtime process may be triggered by the response being received from an external application related to the BPEL runtime process. Rehydration of the BPEL runtime process using the data blob associated with the dehydrated BPEL runtime process may include instantiating the live variables as stored in the data blob. Variables that were not stored as live as part of the data blob may not be instantiated during rehydration.
Following rehydration, execution of the BPEL runtime process instance of the BPEL composite application may continue at step 880 from the point where the BPEL runtime process was dehydrated. At some future point, as represented by the dotted arrow, dehydration may occur again. At this second dehydration point, the same or different variables may be identified as live or not live by the BPEL composite application as defined in the optimization file structure. This process may repeat for as many dehydration/hydration cycles that occur for a BPEL process of a BPEL composite application.
While method 800 is directed to the use of BPEL, it should be understood that a similar method may be applied to other business-process directed programming languages that are configured to have processes dehydrated, or, more generally, other programming languages that are configured to have processes dehydrated.
While the above systems and methods focus on optimizing BPEL code by reducing BPEL data blob size by eliminating variables that are not live, it may be possible to apply similar principles as detailed herein to perform other compiler optimization in BPEL. For example, copy propagation may be optimized using similar techniques. Other possible optimizations include: automatic parallelization, constant folding, algebraic simplifications, value numbering, copy propagation, constant propagation, sparse conditional constant propagation, common subexpression elimination (CSE), partial redundancy elimination, dead code elimination, induction variable elimination, strength reduction, loop optimizations (e.g., loop invariant code motion and loop unrolling), software pipelining, inlining, code generator (optimizations) (e.g., register allocation: local and global, instruction scheduling, branch predication, tail merging and cross jumping, machine idioms and instruction combining), vectorization, phase ordering, profile-guided optimization, and/or macro compression.
FIG. 9 illustrates an embodiment of a method 900 for optimizing BPEL code. Such optimization may be used to perform at least some of the optimizations detailed above. Method 900 may be performed using one or more computer systems.
At step 910, BPEL code may be compiled using a compiler configured to perform one or more optimizations. Such optimizations may include one or more of the optimizations detailed above. At step 920, one or more points with the BPEL code being compiled may be identified that are eligible for the optimization. The identified points may be dehydration points or some other points within the BPEL code where an efficiency may be gained. Such efficiencies may include: decreasing processing time, decreasing complexity, decreasing memory usage, etc. At step 930, optimized executable BPEL code containing the optimization may be created. One or more BPEL runtime processes that are instances of the optimized executable BPEL code may be executed. As executed, the one or more optimizations may be used.
FIG. 10 illustrates an embodiment of a computer system. A computer system as illustrated in FIG. 10 may be incorporated as part of the previously described systems and may be used to perform the previously described methods. For example, computer system 1000 can execute composite applications, external applications, web services, and BPEL compilers. Computer system 1000 may access storage structures, such as storage structure 320. FIG. 10 provides a schematic illustration of one embodiment of a computer system 1000 that can perform the methods provided by various embodiments, as described herein. It should be noted that FIG. 10 is meant only to provide a generalized illustration of various components, any or all of which may be utilized as appropriate. FIG. 10, therefore, broadly illustrates how individual system elements may be implemented in a relatively separated or relatively more integrated manner.
The computer system 1000 is shown comprising hardware elements that can be electrically coupled via a bus 1005 (or may otherwise be in communication, as appropriate). The hardware elements may include one or more processors 1010, including without limitation one or more general-purpose processors and/or one or more special-purpose processors (such as digital signal processing chips, graphics acceleration processors, and/or the like); one or more input devices 1015, which can include without limitation a mouse, a keyboard, and/or the like; and one or more output devices 1020, which can include without limitation a display device, a printer, and/or the like.
The computer system 1000 may further include (and/or be in communication with) one or more non-transitory storage devices 1025, which can comprise, without limitation, local and/or network accessible storage, and/or can include, without limitation, a disk drive, a drive array, an optical storage device, solid-state storage device such as a random access memory (“RAM”) and/or a read-only memory (“ROM”), which can be programmable, flash-updateable, and/or the like. Such storage devices may be configured to implement any appropriate data stores, including without limitation, various file systems, database structures, and/or the like.
The computer system 1000 might also include a communications subsystem 1030, which can include without limitation a modem, a network card (wireless or wired), an infrared communication device, a wireless communication device and/or chipset (such as a BluetoothTM device, an 802.11 device, a WiFi device, a WiMax device, cellular communication facilities, etc.), and/or the like. The communications subsystem 1030 may permit data to be exchanged with a network (such as the network described below, to name one example), other computer systems, and/or any other devices described herein. In many embodiments, the computer system 1000 will further comprise a working memory 1035, which can include a RAM or ROM device, as described above.
The computer system 1000 also can comprise software elements, shown as being currently located within the working memory 1035, including an operating system 1040, device drivers, executable libraries, and/or other code, such as one or more application programs 1045, which may comprise computer programs provided by various embodiments, and/or may be designed to implement methods, and/or configure systems, provided by other embodiments, as described herein. Merely by way of example, one or more procedures described with respect to the method(s) discussed above might be implemented as code and/or instructions executable by a computer (and/or a processor within a computer); in an aspect, then, such code and/or instructions can be used to configure and/or adapt a general purpose computer (or other device) to perform one or more operations in accordance with the described methods.
A set of these instructions and/or code might be stored on a non-transitory computer-readable storage medium, such as the storage device(s) 1025 described above. In some cases, the storage medium might be incorporated within a computer system, such as computer system 1000. In other embodiments, the storage medium might be separate from a computer system (e.g., a removable medium, such as a compact disc), and/or provided in an installation package, such that the storage medium can be used to program, configure, and/or adapt a general purpose computer with the instructions/code stored thereon. These instructions might take the form of executable code, which is executable by the computer system 1000 and/or might take the form of source and/or installable code, which, upon compilation and/or installation on the computer system 1000 (e.g., using any of a variety of generally available compilers, installation programs, compression/decompression utilities, etc.), then takes the form of executable code.
It will be apparent to those skilled in the art that substantial variations may be made in accordance with specific requirements. For example, customized hardware might also be used, and/or particular elements might be implemented in hardware, software (including portable software, such as applets, etc.), or both. Further, connection to other computing devices such as network input/output devices may be employed.
As mentioned above, in one aspect, some embodiments may employ a computer system (such as the computer system 1000) to perform methods in accordance with various embodiments of the invention. According to a set of embodiments, some or all of the procedures of such methods are performed by the computer system 1000 in response to processor 1010 executing one or more sequences of one or more instructions (which might be incorporated into the operating system 1040 and/or other code, such as an application program 1045) contained in the working memory 1035. Such instructions may be read into the working memory 1035 from another computer-readable medium, such as one or more of the storage device(s) 1025. Merely by way of example, execution of the sequences of instructions contained in the working memory 1035 might cause the processor(s) 1010 to perform one or more procedures of the methods described herein.
The terms “machine-readable medium” and “computer-readable medium,” as used herein, refer to any medium that participates in providing data that causes a machine to operate in a specific fashion. In an embodiment implemented using the computer system 1000, various computer-readable media might be involved in providing instructions/code to processor(s) 1010 for execution and/or might be used to store and/or carry such instructions/code. In many implementations, a computer-readable medium is a physical and/or tangible storage medium. Such a medium may take the form of a non-volatile media or volatile media. Non-volatile media include, for example, optical and/or magnetic disks, such as the storage device(s) 1025. Volatile media include, without limitation, dynamic memory, such as the working memory 1035.
Common forms of physical and/or tangible computer-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, or any other magnetic medium, a CD-ROM, any other optical medium, punchcards, papertape, any other physical medium with patterns of holes, a RAM, a PROM, EPROM, a FLASH-EPROM, any other memory chip or cartridge, or any other medium from which a computer can read instructions and/or code.
Various forms of computer-readable media may be involved in carrying one or more sequences of one or more instructions to the processor(s) 1010 for execution. Merely by way of example, the instructions may initially be carried on a magnetic disk and/or optical disc of a remote computer. A remote computer might load the instructions into its dynamic memory and send the instructions as signals over a transmission medium to be received and/or executed by the computer system 1000.
The communications subsystem 1030 (and/or components thereof) generally will receive signals, and the bus 1005 then might carry the signals (and/or the data, instructions, etc. carried by the signals) to the working memory 1035, from which the processor(s) 1010 retrieves and executes the instructions. The instructions received by the working memory 1035 may optionally be stored on a non-transitory storage device 1025 either before or after execution by the processor(s) 1010.
The methods, systems, and devices discussed above are examples. Various configurations may omit, substitute, or add various procedures or components as appropriate. For instance, in alternative configurations, the methods may be performed in an order different from that described, and/or various stages may be added, omitted, and/or combined. Also, features described with respect to certain configurations may be combined in various other configurations. Different aspects and elements of the configurations may be combined in a similar manner. Also, technology evolves and, thus, many of the elements are examples and do not limit the scope of the disclosure or claims.
Specific details are given in the description to provide a thorough understanding of example configurations (including implementations). However, configurations may be practiced without these specific details. For example, well-known circuits, processes, algorithms, structures, and techniques have been shown without unnecessary detail in order to avoid obscuring the configurations. This description provides example configurations only, and does not limit the scope, applicability, or configurations of the claims. Rather, the preceding description of the configurations will provide those skilled in the art with an enabling description for implementing described techniques. Various changes may be made in the function and arrangement of elements without departing from the spirit or scope of the disclosure.
Also, configurations may be described as a process which is depicted as a flow diagram or block diagram. Although each may describe the operations as a sequential process, many of the operations can be performed in parallel or concurrently. In addition, the order of the operations may be rearranged. A process may have additional steps not included in the figure. Furthermore, examples of the methods may be implemented by hardware, software, firmware, middleware, microcode, hardware description languages, or any combination thereof. When implemented in software, firmware, middleware, or microcode, the program code or code segments to perform the necessary tasks may be stored in a non-transitory computer-readable medium such as a storage medium. Processors may perform the described tasks.
Having described several example configurations, various modifications, alternative constructions, and equivalents may be used without departing from the spirit of the disclosure. For example, the above elements may be components of a larger system, wherein other rules may take precedence over or otherwise modify the application of the invention. Also, a number of steps may be undertaken before, during, or after the above elements are considered. Accordingly, the above description does not bound the scope of the claims.

## Claims

1. A method for reducing a size of a Business Process Execution Language (BPEL) data blob for storage, the method comprising:
identifying, by a computer system, one or more dehydration points within BPEL code;
performing, by the computer system, a liveness analysis for the one or more dehydration points;
identifying, by the computer system, at each of the one or more dehydration points, one or more live variables from a set of variables;
creating, by the computer system, an optimization data structure that for each dehydration point identifies the one or more live variables;
compiling the BPEL code using a BPEL compiler configured to perform the liveness analysis, thereby creating compiled BPEL code;
executing a BPEL process using the compiled BPEL code;
dehydrating the BPEL process at a dehydration point during execution of the BPEL process using the compiled BPEL code; and
identifying, using the optimization data structure, the one or more live variables for the dehydration point.

2. The method for reducing the size of the BPEL data blob for storage of claim 1, wherein at runtime, the optimization data structure is checked when the one or more dehydration points are reached such that the one or more live variables of the set of variables are stored within the BPEL data blob and one or more not-live variables of the set of variables are not stored within the BPEL data blob.

3. The method for reducing the size of the BPEL data blob for storage of claim 1, the method further comprising:
creating, by the computer system, the BPEL data blob that comprises the one or more live variables of the set of variables, but does not comprise not-live variables of the set of variables; and
storing, by the computer system, the BPEL data blob.

4. The method for reducing the size of the BPEL data blob for storage of claim 1, wherein the BPEL data blob is smaller than if the BPEL data blob contained live and not-live variables.

5. The method for reducing the size of the BPEL data blob for storage of claim 1, wherein the optimization data structure is a file that comprises an indication of each variable that is live at each dehydration point of the compiled BPEL code.

6. The method for reducing the size of the BPEL data blob for storage of claim 1, wherein at least some variables of the set of variables are extensible markup language (XML) variables.

7. A method for optimizing a Business Process Execution Language (BPEL) code for execution, the method comprising:
compiling, by a computer system, the BPEL code using a BPEL compiler configured to perform an optimization;
identifying, by the computer system, one or more points within the BPEL code that are eligible for the optimization;
creating, by the computer system, optimized executable BPEL code based on the BPEL code, wherein the optimized executable BPEL code based on the BPEL code has the optimization;
executing a BPEL process using the optimized executable BPEL code;
dehydrating the BPEL process at a dehydration point during execution of the BPEL process using the optimized executable BPEL code; and
identifying, using an optimization data structure, the one or more live variables for the dehydration point.

8. A computer program residing on a non-transitory processor-readable medium for reducing a size of a business-process data blob for storage, the computer program comprising computer-readable instructions configured to cause a computer to:
identify one or more dehydration points within code;
perform a liveness analysis for the one or more dehydration points;
identify at each of the one or more dehydration points, one or more live variables from a set of variables;
create an optimization data structure that for each dehydration point identifies the one or more live variables;
compile the code using a compiler configured to perform the liveness analysis, thereby creating compiled code;
execute a process using the compiled code;
dehydrate the process at a dehydration point during execution of the process using the compiled code; and
identify, using the optimization data structure, the one or more live variables for the dehydration point.

9. The computer program for reducing the size of the business-process data blob of claim 8, wherein at runtime, the optimization data structure is checked when the one or more dehydration points are reached such that the one or more live variables of the set of variables are stored within the business-process data blob and one or more not-live variables of the set of variables are not stored within the business-process data blob.

10. The computer program for reducing the size of the business-process data blob of claim 8, wherein the computer program further comprises computer-readable instructions configured to cause the computer to:
create the business-process data blob that comprises the one or more live variables of the set of variables, but does not comprise not-live variables of the set of variables; and
store the business-process data blob.

11. The computer program for reducing the size of the business-process data blob of claim 8, wherein the business-process data blob is smaller than if the business-process data blob contained live and not-live variables.

12. The computer program for reducing the size of the business-process data blob of claim 8, wherein the optimization data structure is a file that comprises an indication of each variable that is live at each dehydration point of the compiled code.

13. The computer program for reducing the size of the business-process data blob of claim 8, wherein at least some variables of the set of variables are extensible markup language XML variables.

14. The computer program for reducing the size of the business-process data blob of claim 8, wherein the code is business process execution language (BPEL) code.