The FifthGen Scalable Transaction Processor (STP) Software is designed for installation on a High Performance Computer (HPC) Platform to process requests-for-service it receives over an internet connection. The actual fulfillment of the request is performed by application software that runs on one of many parallel processing nodes (the PE). The solution is scalable so that additional processors can be added to the HPC with a linear increase in performance. The system is targeted at high volume, high-availability applications.
A complete STP system is a three-stage client-server system. The first layer is the Client that needs to fulfill a processing request. It sends the request over the network to a Load Balancing Server. The Load Balancing Server routes the request to an idle Host Server. The Host Server
manages a cluster of Processing Element (PE) Servers. The Host routes the request to an idle
Processing Element Server that fulfills it and returns the result to the Client back through the Host and the Load Balancing Server.
The architecture is highly scalable and has built in redundancy. The system can be scaled up by adding a combination of:
- Load Balancing Servers
- Host Servers
- PE Servers
The system has several levels of redundancy:
- The Load Balancing Server insulates the client program from a failed or shutdown Host Server.
- The Host Server insulates the client program from a failed or shut down PE Server.
.Communication between servers uses peer-to-peer TCP/IP protocols The messaging protocol between the Application and Load Balancing Server is identical to that between the Host Server and the PE Server.
Thus in a scaled down minimal configuration the application can talk directly to a PE Server without intermediate Load Balancing and Host Servers.
The three primary software components are the:
- Client Request-for-Service Program
- The Load Balancing Server Program
- The Host Server Program
- The PE Server Program
FifthGen Parallel Systems Software
The goal of using parallel processing is to solve a given problem in less time than it takes to solve the same problem on a single processor. Ideally, two processors should take half the time that two processors take. And so on, as you add more processors, you should be able to reduce processing time accordingly.