What is Scalability?

Scalability is a system ' s ability to process more workload, with a proportional increase in system resource usage. In other words, under a scalable system, if you double the workload, then the system uses twice as many system resources. This sounds obvious, but due to conflicts within the system, the resource usage might exceed twice the original workload.

Examples of poor scalability due to resource conflicts include the following:

Applications requiring significant concurrency management as user populations increase

Increased locking activities

Increased data consistency workload

Increased operating system workload

Transactions requiring increases in data access as data volumes increase

Poor SQL and index design resulting in a higher number of logical I/Os for the same number of rows returned

Reduced availability, because database objects take longer to maintain

An application was said to being unscalable if it exhausts a system resource to the point where no more throughput is possible When it workload is increased. Such applications result in fixed throughputs and poor response times.

Examples of resource exhaustion include the following:

Hardware exhaustion

Table scans in High-volume transactions causing inevitable disk I/O shortages

Excessive network requests, resulting in network and scheduling bottlenecks

Memory allocation causing paging and swapping

Excessive process and thread allocation causing operating system thrashing

This means is application designers must create a design that uses the same resources, regardless of user populations an d data volumes, and does not put loads on the system resources beyond their limits.

System Scalability

Applications that is accessible through the Internet has more complex performance and availability requirements. Some applications is designed and written only for Internet use, but even typical back-office applications-such as a gene RAL Ledger application-might require some or all data to be available online.

Characteristics of the Internet age applications include the following:

Availability hours a day, 365 days a year

Unpredictable and imprecise number of concurrent users

Difficulty in capacity planning

Availability for any type of query

Multitier architectures

Stateless middleware

Rapid Development Timescale

Minimal Time for testing

Figure 2–1 illustrates the classic workload growth curve, with demand growing at a increasing rate. Applications must scale with the increase of workload and also when additional hardware are added to support increasing DEM and. Design errors can cause the implementation to reach its maximum, regardless of additional hardware resources or re-de Sign efforts.

Figure 2–1 Workload Growth Curve

Applications is challenged by very short development timeframes with limited time for testing and evaluation. However, bad design typically means so you must later

Rearchitect and reimplement the system. If you deploy a application with known architectural and implementation limitations on the Internet, and if the workload Exceeds the anticipated demand, then failure is a real possibility. From a business perspective, poor performance can mean a loss of customers. If Web users does not get a response in seven seconds and then the user's attention could be lost forever.

In many cases, the cost of re-designing a system with the associated downtime costs in migrating to new implementations ex Ceeds the costs of properly building the original system. The moral of the story are simple:design and implement with scalability in mind from the start.

Factors preventing Scalability

When building applications, designers and architects should aim for as close to perfect scalability as possible. This is sometimes called linear scalability, where system throughput are directly proportional to the number of CP Us.

In real life, linear scalability are impossible for reasons beyond a designer ' s control. However, making the application design and implementation as scalable as possible should ensure Rformance objectives can be achieved through expansion of hardware and the evolution of CPU technology.

Factors. Prevent linear scalability include:

Poor application design, implementation, and configuration

The application have the biggest impact on scalability. For example:

Poor schema design can cause expensive SQL.

Poor transaction design can cause locking and serialization problems.

Poor connection management can cause Poor response times and unreliable systems.

However, the design isn't the only problem. The physical implementation of the application can be the weak link. For example:

Systems can move to production environments with bad I/O strategies.

The production environment could use different execution plans than those generated in testing.

Memory-intensive applications that allocate a large amount of memory without much thought for freeing the memory at run T IME can cause excessive memory usage.

Inefficient memory usage and memory leaks put a high stress on the operating virtual memory subsystem. This impacts performance and availability.

Incorrect sizing of hardware components

Bad capacity planning of all hardware are becoming less of a problem as relative hardware prices decrease. However, too much capacity can mask scalability problems as the workload is increased on a system.

Limitations of software Components

All software are scalability and resource usage limitations. This applies to application servers, database servers, and operating systems. Application design should not place demands on the software beyond what it can handle.

Limitations of Hardware Components

Hardware is not perfectly scalable. Most multiprocessor computers can get close to linear scaling with a finite number of CPUs, but after a certain point each Additional CPU can increase performance overall, but not proportionately. There might come a time when an additional CPU offers no increase in performance, or even degrades performance. This behavior was very closely linked to the workload and the operating system setup.

Note: These factors is based on Oracle Server performance group ' s experience of tuning unscalable systems.

What is Scalability?