Scalability of applications has become much more complex than buying a larger Windows Server or z / OS mainframe. There is growing not only the ability of a system bypass to user requests well as the numbers, but most are loaded with the management system, handling the remaining priorities react under high load situations, while scaling linearly as possible. A central problem of large systems is the data integrity of the number of transactions with write operations to grow and increases the risk of data locking system slowdown. Often, the maximum number of simultaneous users is seen as a measurement of the scalability, but this is a dangerous abbreviation. The number and type of transactions that are required within a certain time frame, is the only true measure of scalability. The reaction mixture for a transaction should be below a limit to the expected peak transaction load remain. For Java applications is difficult and expensive to predict, to achieve scalable performance. Easy conversion from single server environments to multi-server application can lead to a total throughput to collapse. Adding more data may need the database progressively more resources. Java applications that can immediately work in the test, twenty times slower response time when loaded with concurrent users. The only (very complex) way to really scale Java applications on three levels of servers. The first is an HTTP-driven GUI, the second a Java server, de serialized / the tables of the database of the third stage in Java objects to the application logic to execute. This tree levels are often called clusters, which will not link correctly. Clustering is not vertical fragmentation of the application, but are parallel to each server in tier horizontal context. Sun clustering can only be implemented independently for each of the stages and requires a variety of functions in each. In the case of Web-tier, no server-to-server communication is required, while the other extreme, the database must manage animal transactional consistency of the cluster. This means that the cost of scalability is dramatically different for each of these stages. Management and tuning is completely different than for any good. The HTTP-tier leading SSL encryption and decryption tasks, handle unique client connections through HTTP header with “sticky load balancing” information. HTTP requests are stateless load balancing between servers and forwarded to designated J2EE server for processing. The application is sticky load balancing of Web-tier cluster can support HTTP and Java animal. These Java applications show intra-animal communication complexity, which affects directly scalable performance. The clustering of the database server has a function of the database may be used, but it is impossible for the Java server application of some form of local data caching scale. Common forms are coherent cluster caching, caching and replication completely partitioned caching. Clustered caching maintains data in the Java application level to access the data load requests from the cache, without satisfying the database. The cache must not be too large and data as current as necessary. Not all data up-to-date file. The data cache expires by LRU – least recently used algorithm and the elapsed time. In cluster systems, servers notify each other of changes and data either delete or update the outdated data page. Coherent Clustered Caching must be the same as the application logic to cache pages, synchronize, to ensure a thread-safe implementation. A kind of dual-phase commit on page changes in a distributed cache needs to get transactional consistency of the data. A fully replicated cache but not on the problems of clustered caching modifications but shares with other members of the cluster in a “push” model. While the data access has no measurable latency, a transaction should not be closed until the data has to be serialized from the cache of the database layer. However, this is usually done in lazy writes, and thus risky. The other problem is data lock, because theoretically two servers connected, can access the same data to write at the same time and thus lead to conflicts at the close of the transaction. The solution is partitioned cache with each cluster server has a unique fragment of the complete data set. All data must be cached on other servers, but requires the owners servers are synchronized, but because communication is any-to-any partitioned caches scale linearly with the number of requests and data volume as you add servers. Replicating data from the owner and de-serialization of objects created tables in significant latency. Therefore, the application servers in general ‘object cache database cache to avoid “the additional de-serialization overhead object for multiple queries can. The cache many objects from a cache site in an I / O request will load instead of reading a number of table entries. However, a significantly growing number of applications read more data from a database. especially process oriented applications (and, all of them) data synchronization require via back-end interfaces such as SOA or MQ Series from application silos. More often than not, such interfaces require stateful conversations. In comparison to the database access, Web services based communication are at least an order of magnitude worse performance, response time and throughput. Many things like this to do with the problems of XML defined data structures, the weak, ambiguous and non-canonical XSD-based data definitions and the resulting analysis and validation. To reduce the number of transfers happen SOA requests often a lot of random data, as it may be necessary to avoid multiple data access. Obviously, that is similar to creating a kind of SOA-cache, but without the above-mentioned mechanisms of data parallelism. Web services to data provided will be outdated in principle, always. Web Services transactions are so slow that they are not used for applications involve user interactions, but only for straight-through processes without user intervention. To implement clustered caching for SOA Web Services creates considerable problems, especially because there is no defined mechanism for the push updates and lazy database writes. All this must be implemented manually by the Java programmer and is usually hard coded and application specific. The complexity of the measurement and prediction of hardware and software performance is therefore a very complex task. During my years at IBM one of the key elements in designing a good functioning mainframe environment was on the balanced system approach. The right mix of CPU, RAM, hard drive I / O was necessary to get for your money. today is the need for network bandwidth for the various intricacies of the individual levels is the key element involved while HW is regarded as a cheap commodity. The enormous effort in juggling Web / HTTP cluster, Cluster and Java tier expensive high-availability cluster for the database tier requires huge amounts of raw-HW, the usually is not balanced in order to achieve scalable applications. Most systems offer just enough to function at all. The idea of cloud computing has to do with the provision of virtualized resources to such systems graded adding more overhead for virtualization. Hm It does not sound very professional and well thought out to me … CONCLUSION: Could the considerable effort in dealing with sticky load balancing, transaction-safe Java Caching and database clustering, and the considerable effort of analysis and validation of the XML data for SOA can not be avoided? All of the above reasons, why I have chosen a different route for the Papyrus Platform. Instead of the immense complexity of multi-layered cache – with several conversion table cache sites, objects, and vice versa – I decided to collapse the horizontal structures and work with a pure (vertical) object model of the definition to storage. This allows the use of meta-data repository for application life cycle management and system management much easier and tuning. The proxy replication of the object-relational database of the Papyrus Platform uses a partitioned caching concept, where there is always a unique owner of the data and each server node uses a replicated copy that will either pull or push updates, as per proxy definition. The objects can not be de have to serialize /, as they are temporarily stored on the / replicated / binary. The same mechanism works transparently for all objects via Web services or other back-end interfaces are populated. The disadvantage is that testing or low load, it will not be as fast as a Java app, but appears in the difference it makes linear scale with no additional programming or software if you add more product HW. Papyrus uses the same concepts on all servers, because there are no steps necessary and it does not even virtualization.
Apr 102010