Abstract:
Embodiments presented herein provide techniques for optimizing parallel data flows of a batch processing job using a profile of the processing job. An application retrieves a job profile for a processing job. The processing job has a plurality of processing stages specified in an execution profile. The job profile includes statistical data for at least one of the processing stages obtained during prior executions of the job. The application modifies properties of the execution profile based on the job profile to optimize the execution of the job. The application executes the processing job with the modified execution profile.

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
       [0001]    This application is a continuation of co-pending U.S. patent application Ser. No. 14/205 080, filed Mar. 11, 2014. The aforementioned related patent application is herein incorporated by reference in its entirety. 
     
    
     BACKGROUND 
       [0002]    Enterprise systems employ a variety of approaches to process data. For example, an enterprise may employ batch extract, transform, and load (ETL) processes to retrieve data from external sources (e.g., databases), process as needed by a given enterprise, and store the data in a destination source (e.g., data warehouses, operational data stores, etc.). A developer may design ETL data flows to process the enterprise data sets. Typically, once developed, an ETL data flow may be executed on similar input data sets. 
         [0003]    One common issue in running batch processes on data sets includes using system resources effectively to perform the processes in a relatively fast manner. This issue presents a challenge to developers who, in trying to increase efficiency, may tune different parameters of the data flow design, such as adjusting memory block size, increasing a degree of parallelism, etc. Tuning these parameters often involves a significant amount of tedious guesswork and system monitoring to identify and resolve performance issues. 
       SUMMARY 
       [0004]    Embodiments presently disclosed herein provide a method. The method generally includes retrieving, via a processor, a job profile for the processing job. The processing job has a plurality of processing stages specified in an execution profile. The job profile includes statistical data for at least one of the processing stages obtained during prior executions of the job. The method also generally includes modifying properties of the execution profile based on the job profile to optimize execution of the job. The method also generally includes executing the processing job with the modified execution profile. 
         [0005]    Another embodiment of the invention includes a computer program product, the computer program product comprising a computer-readable storage medium having computer-readable program code embodied therewith. The code, when executed on a processor, may generally perform an operation. The operation generally includes retrieving, via a processor, a job profile for the processing job. The processing job has a plurality of processing stages specified in an execution profile. The job profile includes statistical data for at least one of the processing stages obtained during prior executions of the job. The operation also generally includes modifying properties of the execution profile based on the job profile to optimize execution of the job. The operation also generally includes executing the processing job with the modified execution profile. 
         [0006]    Still another embodiment of the invention includes a system having a processor and a memory containing an operation. The operation generally includes retrieving, via a processor, a job profile for the processing job. The processing job has a plurality of processing stages specified in an execution profile. The job profile includes statistical data for at least one of the processing stages obtained during prior executions of the job. The operation also generally includes modifying properties of the execution profile based on the job profile to optimize execution of the job. The operation also generally includes executing the processing job with the modified execution profile. 
     
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
         [0007]      FIG. 1  illustrates an example computing environment, according to one embodiment. 
           [0008]      FIG. 2  illustrates an example application configured to gather profile data and apply the profile data to processing jobs to increase performance, according to one embodiment. 
           [0009]      FIG. 3  illustrates an example interface for the application that allows a developer to gather profile data and optimize data flows for a processing job using the profile data, according to one embodiment. 
           [0010]      FIG. 4  illustrates a method for gathering profile data of a processing job, according to one embodiment. 
           [0011]      FIG. 5  illustrates example profile data obtained by an application for a sort stage operation, according to one embodiment. 
           [0012]      FIG. 6  illustrates a method for applying a profile to a processing job to optimize the processing job, according to one embodiment. 
           [0013]      FIG. 7  illustrates an example server computing system, according to one embodiment. 
       
    
    
     DETAILED DESCRIPTION 
       [0014]    Developers frequently use trial-and-error adjustments to tune a data flow of a job to achieve better performance. For example, in extract, transform, and load (ETL) processing jobs, the developer may adjust memory block size or a degree of parallelism for better efficiency and faster performance. However, identifying which particular parameters to tune, as well as optimal settings for such parameters often requires a significant amount of guesswork and time. 
         [0015]    For example, assume a developer creates a parallel data processing job that processes 100 GB of data from a database using four ETL servers and that the processing job requires that incoming data be sorted before removing any duplicate records. Further, assume that a default sort memory block is 20 MB. With this block size, the servers may use sorting algorithms that require many non-final merge operations with sort files on disk. This results in higher disk input and output operations, slowing performance overall. If the developer does not immediately identify the cause of the problem, the developer might spend a considerable amount of time determining the cause and experiment with several different block sizes to determine how to reduce the number of the non-final merge operations. 
         [0016]    Consider another example where a processing job processes 10 MB of data that requires five different sort operations. If the default sort memory block size is 20 MB, then the resulting process uses 100 MB total for the sort operations, even though only 50 MB is actually required. 
         [0017]    Embodiments presented herein provide techniques for optimizing data flows using profile data generated from executing batch processing jobs, such as ETL processing jobs. For example, an underlying server application may perform guided optimizations on a batch processing job, using information obtained from a previous runs on of that job (e.g., using a similar data set). In one embodiment, the server application gathers statistical data during runtime of a parallel processing job. Such statistical data may include total data processed, average record size processed, access patterns of records, data used in lookup tables, etc. The application generates a profile based on the statistical data. During subsequent runs of the processing job (e.g., using similar input data sets), the application applies the profile to the processing job to optimize specified aspects of job stages, such as in sort operations, block sizes, and parallelization. In one embodiment, the application may provide an interface used to generate and apply a profile to a batch job. For example, after a developer has written a processing job, the developer may specify, through the interface, to run the processing job on an input data set and generate a profile based on the job. In response, the server application produces the profile from statistical data collected at each processing stage (e.g., sort, partition, compress, etc.) The developer may then specify, through the interface, to apply the profile to the processing job to subsequent runs of that job (e.g., with the same data set or subsequent data sets). The interface may allow the developer to specify particular optimizations to perform during subsequent runs, such as sort operation optimizations, parallelization optimizations, record layout optimizations, and so on. The application optimizes the processing job based on the specified optimizations and runs the optimized processing job. 
         [0018]    A profile generated for a batch job allows subsequent runs of a processing job to be optimized. Applying optimizations based on the profile significantly reduces the need to monitor system performance to identify optimizations, particularly for new jobs. That is, self-tuning optimizations may improve the original batch processing job. Further, once tuned, a sophisticated user may fine-tune the profile-based optimizations. This approach also reduces the need for manual tuning by the developer to obtain increased processing job performance. For example, if the profile or input data changes over time, the developer may generate new profile data without needing to manually re-optimize the job. 
         [0019]    Note, the following description relies on an extract, transform, and load (ETL) architecture as a reference example of a computing infrastructure that uses generated profile data for parallel data flows to optimize performance of the data flows when subsequently run. However, one of skill in the art will recognize that the techniques described herein are applicable in other contexts related to gathering statistical data at a data flow level for use in subsequently improving performance of processes in a data flow. For example, the techniques may generally be adapted to systems configured to perform batch processing, such as for automated transaction processing, watermarking, file format conversion, and the like. 
         [0020]      FIG. 1  illustrates an example computing environment  100 , according to one embodiment. As shown, the computing environment  100  includes an ETL server  105  connected to a network  120 . The ETL server  105  may be a physical computing system (e.g., a system in a data center) or may be a virtual computing instance executing within a computing cloud. Generally, the ETL server  105 , through an application  106 , performs parallel batch processing jobs to retrieve data from a source database  110 , transform the data to conform to specified operational needs, and store the transformed data into a target database  115  (e.g., a data warehouse, a data store, etc.). An example of an ETL processing job performed by the application  106  may include a sequential file read operation, a sorting operation, and a peek operation. 
         [0021]    Illustratively, the ETL server  105  includes the application  106 , data flows  107 , and profile data  108 . In one embodiment, the application  106  is further configured to generate profile data  108  for the data flows  107  based on statistical data gathered from running the data flows  107 . Generally, a parallel processing job has many independent threads or processes executing different logic on data flowing through the job. The application  106  gathers profile data at each process. Once generated, the application  106  may apply the profile data  108  to optimize the performance of the data flows  107 . 
         [0022]    As stated, the profile data  108  includes statistical data for a data flow  107 . The application  106  uses the gathered data to tune various parameters of the data flow  107  in subsequent runs of the data flow  107 . For example, assume that the data flow  107  includes a sort operation. During an initial run of the data flow  107 , the application  106  may gather total data processed by each sort instance in the data flow  107 . The application  106  may later use this statistic to tune memory blocks used in each sort instance to avoid computationally-expensive non-final merge operations. As another example, the application  106  may gather processor usage data for each process within the data flow  107 . The application  106  may later use the usage data to identify operators that may benefit from increased parallelism. Other examples of statistical data gathered for the profile data  108  may include an average record size processed by inter-process data transfer blocks (e.g., used to tune each in-memory transfer blocks in the processing job), a maximum fill percentage buffer (e.g., used to increase the size of the memory block used by the buffer to avoid spillage to disk), access patterns of record fields for each process (e.g., used to modify a record layout to place fields accessed more often to increase access speed), average actual data size for bounded fields (e.g., used to tune an internal representation of bounded length fields to reduce memory usage), presence of bottlenecks (e.g., used to increase parallelism to eliminate the bottlenecks), data used in lookup tables (e.g., used to reduce an amount of chaining in the tables), data content (e.g., used to determine compression algorithms used for compressing in-flight data or blocks of data), memory usage of join stages (e.g., used to determine areas where the memory usage can be reduced), and so on. 
         [0023]      FIG. 2  further illustrates the application  106  configured to gather profile data and apply the profile data to processing jobs to increase performance, according to one embodiment. As shown, the application  106  includes a conductor component  205 , an operator component  210 , and a monitor component  215 . The conductor component  205  configures and launches processing jobs. Further, the conductor component  205  provides modules for creating an execution plan of a processing job. The modules invoke operations included in the job and pass profile parameters specific to each operation. In addition, the conductor component  205  includes a module that processes framework-specific profile data and tunes framework parameters based on a set of rules. The conductor component  205  serializes the execution plan with the optimized framework and profile parameters and passes the parameters to the operator component  210 . 
         [0024]    The operator component  210  includes various modules for gathering profile data for each running process of the processing job. For instance, the operator component  210  may include a module for gathering statistical data for general features of the processing job, such as an amount of data processed by input and output data sets. The operator component  210  may also include modules for gathering profile data specific to certain operations of the processing job, such as profile data specific to sort operations or lookup operations. To do so, each operation may include a flag that indicates to the operator component  210  to collect specific profile data. Such modules provide the information needed to increase the performance of such operations. The monitor component  215  stores job run-time data relayed by the conductor component  205 . 
         [0025]      FIG. 3  illustrates an interface  300  for the application  106  that allows a developer to gather profile data and optimize data flows for a processing job using the profile data, according to one embodiment. As shown, the interface  300  may provide two main options to the developer. One option is to generate profile data. After a developer has finished designing a data flow for a processing job, the developer runs a processing job with this option enabled. With this option enabled, the application  106  gathers profile data for each processing stage of the data flow and stores the profile data as a file for future use. 
         [0026]    The other main option that the interface  300  provides is to use generated profile data on the same processing job (e.g., on similar sets of input data). After the application  106  has generated profile data for a particular processing job, the developer may select, through the interface  300 , this option and multiple optimization options for improving the performance of the processing job. 
         [0027]    The interface  300  provides several examples of optimizations that the developer may select. Illustratively, the interface  300  allows the developer to specify optimizations in sort operations, transfer block size, buffer block size, record layout, bounded field, and parallelization. When the application  106  receives a selection of optimizations, the application  106  performs the selected optimizations on the data flow and then runs the optimized data flow. 
         [0028]      FIG. 4  illustrates a method for gathering profile data of a processing job, according to one embodiment. At step  405 , the application  106  receives an indication (e.g., from a developer) to run a batch processing job and gather profile data during the run. The application  106  transmits the indication to the operator component to gather profile data during each stage of the batch processing job. At step  410 , the conductor component of the application  106  initiates the batch processing job. 
         [0029]    At step  415 , at each stage of the job, the operator component of the application  106  gathers profile data. As stated, the operator component gathers data that is general to the processing job (e.g., data amounts) and data that is specific to each stage of the processing job. To gather data that is specific to a given stage, the operator component may detect whether the corresponding operation has a flag that indicates whether specified data should be collected for the stage. If so, the operator component gathers the specific data. For example, a sort stage may have such a flag set. The operator component detects the flag and may gather information during the stage, such as block size information, the overall size of data being processed, etc. The operator component, after gathering data at each stage, inserts the data in a profile data file. 
         [0030]    At step  420 , the application  106  determines whether a previous profile data file for the job exists. If so, at step  425 , the application  106  merges the gathered profile data with the profile data stored with the ETL server into a single profile data file. By merging newly gathered profile data of a subsequently processed run with existing data of a previously processed run, the application  106  may make further optimizations for the processing job. At step  430 , the ETL server stores the profile data. 
         [0031]      FIG. 5  illustrates example profile data obtained by the application  106  for a sort stage operation, according to one embodiment. Illustratively, the profile data corresponds to statistical data obtained for a sort stage on a data partition in a processing job. As shown, the profile data for the sort stage includes general profile information for the partition, such as a stage type, a stage name, and partition identifier. The application  106  collects and stores the profile data as operational metadata specific to the processing job. 
         [0032]    The profile data further provides information specifically gathered for a sort operation, such as a memory block size used in kilobytes and an amount of data spilled to disk in kilobytes. According to the information collected, the memory block size used in this sort stage was 20,480 KB (i.e., 20 MB), and the amount of data spilled to disk was 10,240 KB (i.e., 10 MB) of data was spilled to disk. In subsequent runs, the application  106  may increase the memory block size to avoid the cost of spilling data to the disk. 
         [0033]      FIG. 6  illustrates a method for applying a profile to a processing job to optimize the processing job, according to one embodiment. Assume that a developer had previously run a given processing job through the application  106  and generated profile data for the processing job. At step  605 , the application  106  receives an indication (e.g., from a developer) to run the processing job with optimizations enabled. For example, assume that a developer, through an interface of the application  106 , enables the application  106  to optimize sort operations for a processing job for 10 MB of data that requires five separate sort operations. 
         [0034]    At step  610 , the application  106  loads the profile data file. In one embodiment, the application  106  gather profile data in subsequent runs. Therefore, the profile data file may include data from multiple profile gathering runs. If so, the conductor component of the application  106  merges the multiple runs into a single execution plan. By obtaining statistical data for the profile during subsequent runs of a processing job, the application  106  may make further optimizations to the data flows of the processing job. 
         [0035]    At step  615 , the conductor component scans each stage of the execution plan and determines whether to apply any applicable profile data optimizations to the stage. For example, if the application  106  previously received an indication to optimize sort operations, the operator component applies optimizations based on information gathered in a previous run and stored in the profile data file. Continuing the example of the processing job described above, assume that the default sort memory block size is 20 MB. Without any optimizations, running the job process uses 100 MB total in sort operations, although only 50 MB is required. However, based the information provided in the profile, the conductor component adjusts the sort memory block size to 10 MB. 
         [0036]    At step  620 , the conductor component runs the optimized processing job. Continuing the previous example, assume that the conductor component adjusted the sort memory block size to 10 MB. As a result, the processing job uses only 50 MB in performing sort operations during the sort stage of the processing job, allowing for increased efficiency in running the processing job. 
         [0037]      FIG. 7  illustrates an example ETL server computing system  700 , according to one embodiment. As shown, the server computing system  700  includes, without limitation, a central processing unit (CPU)  705 , a network interface  715 , an interconnect (i.e., bus)  717 , a memory  720 , and storage  730 . The server computing system  700  also may include an I/O device interface  710  connecting I/O devices  712  (e.g., keyboard, display, and mouse devices) to the ETL server computing system  700 . 
         [0038]    The CPU  705  may retrieve and execute programming instructions stored in the memory  720 . Similarly, the CPU  705  may retrieve and store application data residing in the memory  720 . The interconnect  717  may facilitate transmission, such as of programming instructions and application data, among the CPU  705 , I/O device interface  710 , storage  730 , network interface  715 , and memory  720 . CPU  705  is included to be representative of a single CPU, multiple CPUs, a single CPU having multiple processing cores, and the like. Additionally, the memory  720  is included to be representative of a random access memory. Furthermore, the storage  730  may be a disk drive storage device. As shown, the memory  720  includes the application  722 . 
         [0039]    Although shown as a single unit, the storage  730  may be a combination of fixed and/or removable storage devices, such as fixed disc drives, floppy disc drives, tape drives, removable memory cards or optical storage, network attached storage (NAS), or a storage area-network (SAN). As shown, the storage  730  includes data flows  732  and profile data  734 . 
         [0040]    The application  722  is configured to run ETL processing jobs. In one embodiment, the application  722  is further configured to generate profile data  734  based on the data flows  732  of the ETL processing jobs. In addition, the application  722  is configured to modify the data flows  732  using the generated profile data  732  to improve performance of subsequent runs of the data flows  732 . The application  722  itself includes a conductor component  723 , an operator component  725 , and a monitor component  727 . The conductor component  723  configures and launches processing jobs. The operator component  725  is configured to gather statistical data for each running process of the ETL processing job to create the profile data  734 . The monitor component  727  stores run-time data of the job related by the conductor component  723 . After the profile data  734  is generated, the conductor component  723  may load the profile data  734  and adjust parameters in an execution plan for the data flows  732  that improve the performance of the processing job. 
         [0041]    The descriptions of the various embodiments of the present invention have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein. 
         [0042]    As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon. 
         [0043]    Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. 
         [0044]    A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. 
         [0045]    Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing. 
         [0046]    Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). 
         [0047]    Aspects of the present invention are described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. 
         [0048]    These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks. 
         [0049]    The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. 
         [0050]    Embodiments of the invention may be provided to end users through a cloud computing infrastructure. Cloud computing generally refers to the provision of scalable computing resources as a service over a network. More formally, cloud computing may be defined as a computing capability that provides an abstraction between the computing resource and its underlying technical architecture (e.g., servers, storage, networks), enabling convenient, on-demand network access to a shared pool of configurable computing resources that can be rapidly provisioned and released with minimal management effort or service provider interaction. Thus, cloud computing allows a user to access virtual computing resources (e.g., storage, data, applications, and even complete virtualized computing systems) in “the cloud,” without regard for the underlying physical systems (or locations of those systems) used to provide the computing resources. 
         [0051]    Typically, cloud computing resources are provided to a user on a pay-per-use basis, where users are charged only for the computing resources actually used (e.g. an amount of storage space consumed by a user or a number of virtualized systems instantiated by the user). A user can access any of the resources that reside in the cloud at any time, and from anywhere across the Internet. In context of the present invention, a user may access applications or related data available in the cloud. For example, the application  106  could execute on a computing system in the cloud and execute a data processing job with profile-based adjustments. In such a case, the application  106  could generate job profile data and store the job profile data at a storage location in the cloud. Doing so allows a user to access this information from any computing system attached to a network connected to the cloud (e.g., the Internet). 
         [0052]    The present invention may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention. 
         [0053]    The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire. 
         [0054]    Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device. 
         [0055]    Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention. 
         [0056]    Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions. 
         [0057]    These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks. 
         [0058]    The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks. 
         [0059]    The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions. 
         [0060]    While the foregoing is directed to embodiments of the present invention, other and further embodiments of the invention may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.