Performance Ponderings

Contents

1  P = FS: Parallel is Just Fast Serial (2020)

We prove that parallel processing with homogeneous processors is logically equivalent to fast serial processing. The reverse proposition can also be used to identify obscure opportunities for applying parallelism. To our knowledge, this theorem has not been previously reported in the queueing theory literature. A plausible explanation is offered for why this might be. The basic homogeneous theorem is also extended to optimizing the latency of heterogenous parallel arrays.

2  Erlang Redux: An Ansatz Method for Solving the M/M/m Queue (2020)

Presents a novel approach to solving the response time (i.e., residence time) of an M/M/m queue. The key idea is the introduction of an ansatz transformation, defined in terms of the Erlang B function, that avoids the more opaque derivation based on applied probability theory. This approach supersedes our earlier approximate morphing transformation.

3  How to Optimize Page Load Times: A Different Slant on the Frustration Index (2019)

My response to a preceding article entitled, FRUSTRATION Index: Mind the Gap by Tim Vereecke, posted on Day 17 of the 2019 Web Performance Calendar.

4  Tomcat-Applikationsperformance in der Amazon-Cloud unter Linux modelliert (2019)

Die Cloud hat mit ihrem Bezahlmodell nach Verbrauch das gute alte Performancemanagement zurück in den Alltag der Sysadmins gebracht. Dieser Artikel erläutert, wie man mit Hilfe von Modellen das kostengünstigste Deployment in einer Amazon-Cloud findet. — Neil Gunther und Mohit Chawla

1. Linux-Magazin, February 2, 2019
   
2. English preprint (PDF)

5  Time: The Zeroth Performance Metric (2018)

Ruminations of the vital importance of timestamps and why they are often missing in web publications.

6  Exposing the Cost of Performance Hidden in the Cloud (2018)

Abstract: Whilst offering lift-and-shift migration and versatile elastic capacity, the cloud also reintroduces an old mainframe concept - chargeback - which thereby rejuvenates the need for traditional performance and capacity management in the new cloud context. Combining production JMX data with an appropriate performance model, we show how to assess fee-based Amazon AWS configurations for a mobile-user application running on a Linux-hosted Tomcat cluster. The performance model also facilitates ongoing cost-benefit analysis of various EC2 Auto Scaling policies.

1. Video presentation
2. Enhanced slides

7  WTF is Modeling, Anyway? (2017)

8  Morphing M/M/m: A New View of an Old Queue (2017)

Abstract: This year is the centenary of A. K. Erlang's 1917 paper on the determination of waiting times in an M/D/m queue with m telephone lines. Today, M/M/m queues are used to model such systems as, call centers, multicore computers and the Internet. Unfortunately, those who should be using M/M/m models often do not have sufficient background in applied probability theory. Our remedy defines a morphing approximation to the exact M/M/m queue that is accurate to within 10% for typical applications. The morphing formula for the residence-time, R(m,ρ), is both simpler and more intuitive than the exact solution involving the Erlang-C function. We have also developed an animation of this morphing process. An outstanding challenge, however, has been to elucidate the nature of the corrections that transform the approximate morphing solutions into the exact Erlang solutions. In this presentation, we show:

• The morphing solutions correspond to the m-roots of unity in the complex z-plane.
• The exact solutions can be expressed as a rational function, R(m,z).
• The poles of R(m,z) lie inside the unit disk, |z| < 1, and converge around the Szegó curve as m is increased.
• The correction factor for the morphing model is defined by the deflated polynomial belonging to R(m,z).
• The pattern of poles in the z-plane provides a convenient visualization of how the morphing solutions differ from the exact solutions.

9  How to Emulate Web Traffic Using Standard Load Testing Tools (2016)

Abstract: Conventional load-testing tools are based on a fifty-year old time-share computer paradigm where a finite number of users submit requests and respond in a synchronized fashion. Conversely, modern web traffic is essentially asynchronous and driven by an unknown number of users. This difference presents a conundrum for testing the performance of modern web applications. Even when the difference is recognized, performance engineers often introduce modifications to their test scripts based on folklore or hearsay published in various Internet fora, much of which can lead to wrong results. We present a coherent methodology, based on two fundamental principles, for emulating web traffic using a standard load-test environment.

10  Hadoop Superlinear Scalability (2015)

Superlinearity (i.e., speedup > 100%) is a bona fide observable phenomenon that has been discussed qualitatively, but not understood in a rigorous way. We provide that insight.

Superlinear speedup can be expected to be observed more often as new applications move to distributed systems. Therefore, we believe it's important to understand what superlinear data actually represent and how to address the phenomenon when configuring distributed systems for performance and scalability.

Some of the points covered include:

• Like 'perpetuum mobile,' superlinear performance appears to come for free.
• But our data shows there is a hidden cost that causes degraded scalability.
• The cost arises from latent subsystem constraints.
• Gotchas that Hadoop developers, software engineers, and sysadmins are likely to run into.

11  A Note on Disk Drag Dynamics (2012)

Abstract: The electrical power consumed by typical magnetic hard disk drives (HDD) not only increases linearly with the number of spindles but, more significantly, it increases as very fast power-laws of speed (RPM) and diameter. Since the theoretical basis for this relationship is neither well-known nor readily accessible in the literature, we show how these exponents arise from aerodynamic disk drag and discuss their import for green storage capacity planning.

12  A Methodology for Optimizing Multithreaded System Scalability on Multicores (2011)

Abstract: We show how to quantify scalability with the Universal Scalability Law (USL) by applying it to performance measurements of memcached, J2EE, and Weblogic on multi-core platforms. Since commercial multicores are essentially black-boxes, the accessible performance gains are primarily available at the application level. We also demonstrate how our methodology can identify the most significant performance tuning opportunities to optimize application scalability, as well as providing an easy means for exploring other aspects of the multi-core system design space.

13  A Note on Parallel Algorithmic Speedup Bounds (2011)

Abstract: A parallel program can be represented as a directed acyclic graph. An important performance bound is the time to execute the critical path through the graph. We show how this performance metric is related to Amdahl speedup and the degree of average parallelism. These bounds formally exclude superlinear performance.

14  The Apdex Index Revealed: Triangles Tell The Tale (2009)

Abstract: The purpose of this talk is not to improve upon or redesign the Apdex Index in any way. Rather, it is to explain the significance of the underlying construction of the Apdex Index, as it is currently defined. Then, I want to consider other ways the Apdex metrics might be applied; especially from a performance visualization standpoint.

15  Mind Your Knees and Queues. Responding to Hyperbole with Hyperbolæ (2009)

Abstract: How do you determine where the response-time "knee" occurs? Calculating where the response time suddenly begins to climb dramatically is considered by many to be an important determinant for such things as load testing, scalability analysis, and setting application service targets. This question arose in a CMG MeasureIT article. I responded to it in an unconventional, but rigorous way, in this CMG MeasureIT article.

16  A General Theory of Computational Scalability Based on Rational Functions (2008)

Abstract: The universal scalability law of computational capacity is a rational function Cp = P(p)/Q(p) with P(p) a linear polynomial and Q(p) a second-degree polynomial in the number of physical processors p, that has been long used for statistical modeling and prediction of computer system performance. We prove that Cp is equivalent to the synchronous throughput bound for a machine-repairman with state-dependent service rate. Simpler rational functions, such as Amdahl's law and Gustafson speedup, are corollaries of this queue-theoretic bound. Cp is further shown to be both necessary and sufficient for modeling all practical characteristics of computational scalability.

17  Getting in the Zone for Successful Scalability (2008)

Abstract: The Universal Scalability Law (USL) is an analytic function used to quantify application scaling. It is universal because it subsumes Amdahl's law (AL) and linear scaling (LS) as special cases. Using simulation, we show (1) that USL is equivalent to synchronous queueing in a load-dependent machine repairman model, and (2) how LS, AL and USL can be regarded as boundaries defining three performance zones. Typical throughput measurements lie in all three zones. Simulation scenarios provide insight into which application features should be tuned to get into the optimal performance zone.

18  Object, Measure Thyself: Performance Monitoring and Data Collection (2008)

These guys were involved with the development and deployment of ERMA (Extremely Reusable Monitoring API), and Graphite: the popular open source time-series plotting tool. (See Section 3.2 of the paper) Although I didn't write any code, I did help them write up the instrumentation work done at Orbitz Worldwide in this paper and have them present it at the 2008 CMG conference. Oh! And I came up with the title, which harks back to a previous attempt of mine at a CMG 2002 event to encourage IDE vendors to do something similar in their C⁺⁺ and Java libraries but, due a lack of obvious ROI, that never went anywhere.

1. CMG 2008 paper
2. CMG 2008 slides

19  Multidimensional Visualization of Oracle Performance Using Barry007 (2008)

Abstract: Most generic performance tools display only system-level performance data using 2-dimensional plot or diagram, and this limits the informational detail that can be displayed. A modern relational database system like Oracle, however, can concurrently serve thousands of client processes with different workload characteristics and generic data displays inevitably hide important information. Drawing on our previous work, this paper demonstrates the application of Barry007 (See paper 22) multidimensional visualization for analyzing Oracle end-user session-level performance showing both collective trends and individual performance anomalies.

20  Eine Chance für Linux (2008)

Abstract (Translation): Linux could be in a position to expand its presence in the server market by looking to mainframe computer performance management as a role model and adapting its instrumentation accordingly.

1. German version (PDF)
2. English version (PDF)

21  Better Performance Management Through Better Visualization Tools (2008)

22  Seeing It All at Once with Barry (2007)

1. Paper (PDF),
2. Slides (PDF),
3. Animations (HTML),
4. Tools (HTML).

23  Linux Load Average (2007)

1. German version Load Average Enträtselt und Erweitert: Leistungsdiagnostik (PDF)
2. English version Understanding the load-average metrics in a Linux operating system (PDF)

24  Berechenbare Performance (Predicting Performance) (2007)

1. German version (PDF)
2. English version (PDF)

25  Moore's Law: More or Less? (2007)

26  Visualizing Virtualization (2007)

27  Guerrilla Scalability: How to Do Virtual Load Testing (2007)

28  The Virtualization Spectrum from Hyperthreads to GRIDs (2006)

• Disparate types of virtual machines lie on a discrete spectrum bounded by hyperthreading at one extreme and hyperservices at the other,
• Poll-based scheduling is the common architectural element in most virtual machine implementations.

29  Reconstructing the Future: Capacity Planning with Data That's Gone Troppo (2006)

30  Benchmarking Blunders and Things That Go Bump in the Night (2006)

31  Unification of Amdahl's Law, LogP and Other Performance Models for Message-Passing Architectures (2005)

32  (Numerical) Investigations into Physical Power-law Models of Internet Traffic Using the Renormalization Group (2005)

33  Millennium Performance Problem 1: Performance Visualization (2005)

34  Benchmarking Blunders and Things That Go Bump in the Night (2004)

Abstract: Benchmarking; by which I mean any computer system that is driven by a controlled workload, is the ultimate in performance testing and simulation. Aside from being a form of institutionalized cheating, it also offer countless opportunities for systematic mistakes in the way the workloads are applied and the resulting measurements interpreted. Right test, wrong conclusion is a ubiquitous mistake that happens because test engineers tend to treat data as divine. Such reverence is not only misplaced, it's also a sure ticket to production hell when the application finally goes live. I demonstrate how such mistakes can be avoided by means of two war stories that are real WOPRs. (a) How to resolve benchmark flaws over the psychic hotline and (b) How benchmarks can go flat with too much Java juice. In each case I present simple performance models and show how they can be applied to correctly assess benchmark data.

35  How to Get Unbelievable Load Test Results (2004)

36  Performance Evaluation of Packet-to-Cell Segmentation Schemes in Input Buffered Packet Switches (2003)

37  Unix Load Average Metric (2003-2004)

• Part 1: How It Works
• Part 2: Not Your Average Average
• Part 3: Addendum on Hz vs. HZ

38  Series on Guerrilla Capacity Planning (2003)

• PART 1:Hit-and-Run Tactics for Website Scalability
• PART II: Weapons of Mass Instruction

39  Characterization of the Burst Stabilization Protocol for the RR/CICQ Switch (2003)

40  A New Interpretation of Amdahl's Law and Geometric Scalability (2002)

Amdahl's law for parallel speedup is equivalent to the synchronous queueing
bound on throughput in the repairman model of a symmetric multiprocessor.

41  Hit-and-Run Tactics Enable Guerrilla Capacity Planning (2002)

42  Hypernets: Good (G)news for Gnutella! (2002)

43  Of Buses and Bunching: Strangeness in the Queue (2001)

44  Quantifying Application and Server Scalability (2001)

• Commercial Clusters and Scalability
• How to Measure an Elephant
• Evaluating Scalability Parameters: A Fitting End

45  How to Write Application Probes (Updated 2001)

46  Scalability Models for a Hypergrowth e-Commerce Website (2000)

47  BIRDS-I: A Benchmark for Image Retrieval on the Internet (2000)

48  Solaris Resource Manager: All I Ever Wanted Was My Unfair Advantage ... and Why You Can't Get It! (1999)

Traditional UNIX time-share schedulers attempt to be fair to all users by employing a round-robin style algorithm for allocating CPU time. Unfortunately, a loophole exists whereby the scheduler can be biased in favor of a greedy user running many short CPU-bound processes. This loophole is not a defect but an intrinsic property of the round-robin scheduler that ensures responsiveness to the short CPU demands associated with multiple interactive users. A new generation of UNIX system resource management (SRM) software constrains the scheduler to be equitable to all users regardless of the number of processes each may be running. This fair-share scheduling draws on the concept of prorating resource "shares" across users and groups and then dynamically adjusting CPU usage to meet those share proportions. The simple notion of statically allocating these shares, however, belies the potential consequences for performance as measured by user response time and service level targets. We demonstrate this point by modeling several simple share allocation scenarios and analyzing the corresponding performance effects. A brief comparison of commercial SRM implementations from Hewlett-Packard, IBM, and Sun Microsystems is also presented.

49  Microsoft Windows NT Scalability (1997-1998)

1. NT to the Max (NoT!) — Nov (1997)
2. The ABCs of TPCs — Feb (1998)
3. How to Stack Cyberbrix — Jun (1998)

50  The MP Effect: Parallel Processing in Pictures (1996)

51  A Simple Capacity Model of Massively Parallel Transaction Systems (1993)

52  Performance Collapse of Networks (1988)