Print this page Share

Solving Enterprise Applications Performance Puzzles: Queuing Models to the Rescue

ISBN: 978-1-118-06157-2
256 pages
February 2012, Wiley-IEEE Press
Solving Enterprise Applications Performance Puzzles: Queuing Models to the Rescue (1118061578) cover image
Poorly performing enterprise applications are the weakest links in a corporation's management chain, causing delays and disruptions of critical business functions. This groundbreaking book frames enterprise application performance engineering not as an art but as applied science built on model-based methodological foundation. The book introduces queuing models of enterprise application that visualize, demystify, explain, and solve system performance issues. Analysis of these models will help to discover and clarify unapparent connections and correlations among workloads, hardware architecture, and software parameters.
See More
Acknowledgments ix

Preface xi

1. Queuing Networks as Applications Models 1

1.1. Enterprise Applications—What Do They Have in Common?, 1

1.2. Key Performance Indicator—Transaction Time, 6

1.3. What Is Application Tuning and Sizing?, 8

1.4. Queuing Models of Enterprise Application, 9

1.5. Transaction Response Time and Transaction Profi le, 19

1.6. Network of Highways as an Analogy of the Queuing Model, 22

Take Away from the Chapter, 24

2. Building and Solving Application Models 25

2.1. Building Models, 25

Hardware Specification, 26

Model Topology, 28

A Model’s Input Data, 29

Model Calibration, 31

2.2. Essentials of Queuing Networks Theory, 34

2.3. Solving Models, 39

2.4. Interpretation of Modeling Results, 47

Hardware Utilization, 47

Server Queue Length, Transaction Time, System Throughput, 51

Take Away from the Chapter, 54

3. Workload Characterization and Transaction Profiling 57

3.1. What Is Application Workload?, 57

3.2. Workload Characterization, 60

Transaction Rate and User Think Time, 61

Think Time Model, 65

Take Away from the Think Time Model, 68

Workload Deviations, 68

“Garbage in, Garbage out” Models, 68

Realistic Workload, 69

Users’ Redistribution, 72

Changing Number of Users, 72

Transaction Rate Variation, 75

Take Away from “Garbage in, Garbage out” Models, 78

Number of Application Users, 78

User Concurrency Model, 80

Take Away from User Concurrency Model, 81

3.3. Business Process Analysis, 81

3.4. Mining Transactional Data from Production Applications, 88

Profi ling Transactions Using Operating System Monitors and Utilities, 88

Application Log Files, 90

Transaction Monitors, 91

Take Away from the Chapter, 93

4. Servers, CPUs, and Other Building Blocks of Application Scalability 94

4.1. Application Scalability, 94

4.2. Bottleneck Identification, 95

CPU Bottleneck, 97

CPU Bottleneck Models, 97

CPU Bottleneck Identification, 97

Additional CPUs, 100

Additional Servers, 100

Faster CPUs, 100

Take Away from the CPU Bottleneck Model, 104

I/O Bottleneck, 105

I/O Bottleneck Models, 106

I/O Bottleneck Identification, 106

Additional Disks, 107

Faster Disks, 108

Take Away from the I/O Bottleneck Model, 111

Take Away from the Chapter, 113

5. Operating System Overhead 114

5.1. Components of an Operating System, 114

5.2. Operating System Overhead, 118

System Time Models, 122

Impact of System Overhead on Transaction Time, 123

Impact of System Overhead on Hardware Utilization, 124

Take Away from the Chapter, 125

6. Software Bottlenecks 127

6.1. What Is a Software Bottleneck?, 127

6.2. Memory Bottleneck, 131

Memory Bottleneck Models, 133

Preset Upper Memory Limit, 133

Paging Effect, 138

Take Away from the Memory Bottleneck Model, 143

6.3. Thread Optimization, 144

Thread Optimization Models, 145

Thread Bottleneck Identification, 145

Correlation Among Transaction Time, CPU

Utilization, and the Number of Threads, 148

Optimal Number of Threads, 150

Take Away from Thread Optimization Model, 151

6.4. Other Causes of Software Bottlenecks, 152

Transaction Affinity, 152

Connections to Database; User Sessions, 152

Limited Wait Time and Limited Wait Space, 154

Software Locks, 155

Take Away from the Chapter, 155

7. Performance and Capacity of Virtual Systems 157

7.1. What Is Virtualization?, 157

7.2. Hardware Virtualization, 160

Non-Virtualized Hosts, 161

Virtualized Hosts, 165

Queuing Theory Explains It All, 167

Virtualized Hosts Sizing After Lesson Learned, 169

7.3. Methodology of Virtual Machines Sizing, 171

Take Away from the Chapter, 172

8. Model-Based Application Sizing: Say Good-Bye to Guessing 173

8.1. Why Model-Based Sizing?, 173

8.2. A Model’s Input Data, 177

Workload and Expected Transaction Time, 177

How to Obtain a Transaction Profile, 179

Hardware Platform, 182

8.3. Mapping a System into a Model, 186

8.4. Model Deliverables and What-If Scenarios, 188

Take Away from the Chapter, 193

9. Modeling Different Application Configurations 194

9.1. Geographical Distribution of Users, 194

Remote Office Models, 196

Users’ Locations, 196

Network Latency, 197

Take Away from Remote Offi ce Models, 198

9.2. Accounting for the Time on End-User Computers, 198

9.3. Remote Terminal Services, 200

9.4. Cross-Platform Modeling, 201

9.5. Load Balancing and Server Farms, 203

9.6. Transaction Parallel Processing Models, 205

Concurrent Transaction Processing by a Few Servers, 205

Concurrent Transaction Processing by the Same Server, 209

Take Away from Transaction Parallel Processing Models, 213

Take Away from the Chapter, 214

Glossary 215

References 220

Index 223

See More
Solving Enterprise Applications Performance Puzzles : Queuing Models to the Rescue by Leonid Grinshpan is a pretty interesting book about application of queuing models to solving enterprise performance and I believe the book fills a few gaps in practical application of queuing theory. Another good name for this book could be “Building queuing models by example”.

I spent a lot of time trying to use queuing models to solve practical performance issues and would testify that it is pretty challenging. There are a few areas where it was developed a little further (for example, around capacity planning of existing systems), but if you trying to do something else – you won’t find much help. You have a lot of books about systems performance, you have a lot of books about queuing theory with simple examples, but not much in between to solve practical tasks. And here Leonid’s book may help, especially if you are new in this area.

Chapter 1, Queuing Networks as Applications Models, is an introduction into the topic. It discusses how queuing theory may be used to model enterprise applications. A lot of analogues are used to introduce the subject.

Chapter 2, Building and Solving Application Models, is an overview of the whole process, including short discussions about essentials of queuing theory and using of tools to solve models.

Chapter 3, Workload Characterization and Transaction Profiling, discusses what input data for models are and how to gather them.

Chapter 4, Servers, CPUs, and Other Building Blocks of Application Scalability, discusses scalability, bottlenecks, how to identify bottlenecks and ways to fix them (mostly on CPU and I/O examples).

Chapter 5, Operating System Overheads, discusses main components of operating systems, where overheads come from, how to measure them, and their impact on transaction time.

Chapter 6, Software Bottlenecks, is devoted to software bottlenecks, which are rarely discussed in application to queuing models – while in practice software bottlenecks happen all the time. Memory bottlenecks and thread optimizations and their modeling are discussed in details. Multiple other software bottlenecks are also reviewed.

Chapter 7, Performance and Capacity of Virtual Systems, is an overview of performance issues related to virtualization , their explanation with queuing theory, and a methodology of virtual machine sizing.

Chapter 8, Model-Based Application Sizing: Say Good-Bye to guessing, explains why to use model-based sizing and discusses it step-by-step from gathering input data to model deliverables and what-if scenarios.

Chapter 9, Modeling Different Application Configurations, discusses several specials cases including geographical distribution of users, cross-platform modeling, remote terminal services, load balancing, and parallelization of transactions.

The book covers a lot of topics. However, to avoid disappointments, I’d like to point out what this book is not:

- It is not a textbook about queuing theory. The section 2.2 Essentials of Queuing Networks Theory has 5 pages in it.

- It is not a book about tools to solve queuing models. Available tools are listed and there are references, but they are just mentioned as a way to solve models (with one tool used as an illustration of the process). You don’t need to know any tool to read the book (but you will need one when you try to solve your own models).

- It is not a comprehensive book about enterprise application performance. There is plenty of important information and practical recommendations about enterprise application performance in the book, but it is shared as needed to build models and analyze their results.

So the book is exactly what the title says: a practical book about building queuing models to investigate enterprise applications performance issues.

- Alexander Podelko, Oracle

See More
Buy Both and Save 25%!

Solving Enterprise Applications Performance Puzzles: Queuing Models to the Rescue (US $72.95)

-and- The Dark Side of Software Engineering: Evil on Computing Projects (US $40.95)

Total List Price: US $113.90
Discounted Price: US $85.42 (Save: US $28.48)

Buy Both
Cannot be combined with any other offers. Learn more.
Back to Top