- Mechanical Solutions: Parallel Computing at the Operating System Level
- Automated Network Routing: Parallel Computing by Predetermined Logic
- Grid Computing: Parallel Computing by Distribution
- Parallel Computing for Business Applications
- The Solution: Software Pipelines
- Fluid Dynamics
- Software Pipelines Example
The Solution: Software Pipelines
Imagine the ideal implementation for a business environment:
- You can divide any application process or portion of a process into discrete tasks or services and perform them anywhere in a given network (local or remote), in parallel with other tasks whenever possible. You can define the granularity of tasks to fit the specific needs of each application; the size can range from coarse-grained (such as Web services) down to fine-grained (such as class/method calls). In addition, the system optimizes resource utilization of all available facilities, because it dynamically shifts available resources to handle current demand.
The idea is simple, but the details are often complex, with a multitude of potential variations and design patterns. The solution is Software Pipelines architecture, which supports the following features and capabilities:
- You can decompose business processes into specific tasks, then execute them in parallel.
- It has virtually unlimited peer-to-peer scalability.
- It’s easier on the developer because it provides an easy method for distributing and executing tasks in parallel—on one server, or across many servers.
- It’s specifically designed for business applications, particularly those that use, or can use, SOA.
- It handles a high volume of transactions, both large and small, and is therefore ideal for mixed-workload processing.
- The design gives you control of throughput and task distribution, which means that you can maximize your computing resources.
- You can scale upward by using parallel architecture, while still guaranteeing the order of processing—a key business requirement in many mission-critical applications. This is a huge benefit over previous approaches.
- Because the architecture supports so many configurations and patterns, you can create a wide variety of application designs.
These features also allow you to take full advantage of today’s multi-core processors, distributing transactions within and across servers at will.
The fundamental component in Software Pipelines is the pipeline itself, defined as follows:
- An execution facility for invoking the discrete tasks of a business process in an order-controlled manner. You can control the order by using priority, order of message input (for example, FIFO), or both.
Essentially, a pipeline is a control mechanism that receives and performs delegated tasks, with the option of then delegating tasks in turn to other pipelines in the system as required. This means you can use pipelines as building blocks to create an unlimited variety of configurations for accomplishing your specific application objectives.
You can group multiple pipelines into fully distributed, peer-to-peer pools; each pipeline processes a portion of an application or process. And because you can configure each pool to run on a specific local or remote server, the system can execute tasks anywhere on a network.
A pipeline can route tasks to other pipelines through a Pipeline Distributor, its companion component. The Pipeline Distributor is defined as follows:
- A virtual routing facility for distributing a given service request to the appropriate pipeline (which in turn executes the request) within a pipeline pool. The distributor is colocated with its pool of pipelines and effectively front-ends incoming service requests.
- The distributor routes service requests by evaluating message content. Routing is based on configuration rules, which you can easily modify without changing individual business services. You can route requests by using priority, order of message input (such as FIFO), or both.
In Figure 1.2 you can see how pipelines work with distributors. Requests go to the first distributor, which splits them off onto three pipelines. The second pipeline delegates a request to the third pipeline, and the third pipeline sends a request to another distributor, which in turn splits requests onto five pipelines.
Figure 1.2 The Pipeline Distributor and its relationship to pipelines
By using pipeline and distributor components, you can build a fully distributed, multilevel series of interlinked pipelines—and achieve massive scalability through parallel processing.