Stats x Performance


Skeepers Influence Workshop

2022-03-31

Program



Variability and Percentiles


Pareto & Amdahl Laws


Uncertainty and Error


Profiling Your Code

Variability and Percentiles


Example: Height



Distribution of heights in USA, source

Unending source of worries for first time parents

Height Distribution


"Normal" distribution

Important Distributions


Gaussian (normal)



Poisson: random incoming



Binomial: random coins



Zipf: word frequencies


Pareto: riches

Percentiles and Service


The average gives a biased idea of the experience

Percentiles tell a more complete story


Speaking about time per request:
  • 50th percentile (median): half of all requests are above
  • 90th percentile: 1 out of every 10 requests is above
  • 99th percentile: 1 out of every 100 requests is above


Bad 99th percentile, at 100 requests per second:
One failure per second!

Exercise: Total Time


A request uses 10 servers in parallel

50th percentile is 50 ms
90th percentile is 200 ms

Estimate a minimum value for the average time per request

⮯

Exercise +


Simulate a Pareto distribution



xm = 28 ms

α = 1.16

As function U you can use Math.random()

⮯

Exercise +


Simulate 100k Pareto samples

Compute average, minimum, maximum

Compute percentiles: 5, 50, 90, 95, 99, 99.9

To compute percentiles:
  • Sort the array (as numbers!)
  • For 50th percentile, go to the middle of the array
  • For 90th percentile, go to position 90k
  • ...

⮯

Exercise +


Now simulate requests with 10 calls to servers in parallel
= the maximum of 10 Pareto samples

Compute minimum, average, 50th and 90th percentiles

Are they the same as before?


⮯

Exercise +


Finally, simulate requests with 10 sequential calls to servers



=> the result of adding 10 Pareto samples

Compute 50th percentile

Is it 10 times bigger than before?


⮯

Exercise +


As an extra: simulate a request to 10 sequential servers,
each doing 10 requests in parallel


What is the average, minimum, 50th percentile?


⮯

Exercise +


This last part is not fiction

In 2009 a Google search used 1000 servers

Total time 200 ms

Can you think of any way to improve the response time?
⮯

Timed out!



Package pareto-simulator


Install pareto-simulator:

$ npm i -g pareto-simulator

Now test a few commands:

$ pareto --xm 28
$ pareto --xm 28 --parallel 10
$ pareto --xm 28 --series 10
$ pareto --xm 28 --series 10 --parallel 10
$ pareto --xm 1 -n 1000 --parallel 30 --series 30 --timeout 10 --linear

What distributions do they remind you of?

Pareto Law


Rule of 80/20



A 20% of causes generates 80% of effects

Applies to a wide spectrum of phenomena:

Optimization Work


Now it's time for hard work: optimize a service

It consumes too much:
  • CPU
  • memory
  • file descriptors
  • input/output buffers
  • ...


Where do we start?

Locate 🔥hot spots🔥

That's Lucky!



🔥Hot spots🔥 follow the Pareto principle


20% of the code takes 80% of processing time


The law applies recursively...


4% of the code takes 64% of processing time

Is it worth it?



Amdahl Law

An Apparently Complicated Law





Easier



Exercise: Limits of Optimization

Request get in nodecached: 37250 rps

How much can we accelerate nodecached?

⮯

Exercise +


Let us focus on the get operation:
  • 2 µs: string conversion
  • 6 µs: internal processing
  • 7 µs: input
  • 12 µs: output

Let us suppose we optimize string and processing (0µs)

What is the theoretical maximum for requests per second?


⮯

Exercise +


Formula: R [rps] = 1000000 / t [µs]

Exercise of imagination:
What strategies can we follow to optimize more?



⮯

Accelerating!



Law of Diminishing Returns




As we go along in optimization, return of investment goes down


This law is not very rigorous (but it's useful)

Careful with micro-optimization


Uncertainty and Error


Systematic and random errors



Systematic error


Random error

Types of Randomness


White noise

Pink noise


Brown noise

Exercise: Real Distribution



We want to measure the distribution of response times


Requests to service https://reqbin.com/echo



⮯

Exercise +


Download the loadtest project:
 git clone https://github.com/alexfernandez/loadtest.git

Tweak it to show the time for every request


Now send the tests:
node bin/loadtest.js https://reqbin.com/echo -k -n 15000 -c 100 --rps 300

Use rps above and below the value without --rps (e.g. 300 y 500)

⮯

Exercise +


Export the result to a file and extract all numerical values

$ command | grep -v INFO > service-times-300.csv

Draw a histogram with the values

Draw a log-log histogram

What do graphs tell you?


⮯

Awesome!



Exercise +


Profiling Code


Profiling with microprofiler


Package microprofiler

Allows finding out where processing time is spent

Thin layer on process.hrtime()

Sections of code are instrumented:
const start = microprofiler.start()
Start measuring:
microprofiler.measureFrom(start, 'label', 10000)
Measures time between start() and measureFrom()
Shows a summary for label every 10000 calls

Native Profiling


Node.js includes a nice profiler:
$ node --prof ...

It generates a file like isolate-0x440c2f0-28473-v8.log
It can be interpreted with the command:
node --prof-process isolate-0x440c2f0-28473-v8.log

Output has three parts:
  • [Summary]: Summary of times
  • [JavaScript], [C++ entry points]: Sections by language
  • [Bottom up (heavy) profile]: Hierarchical profile

Flamegraphs


Flamegraph Packages


Package 0x






Live demo

Exercise: Saving Microseconds


We want to optimize the code for pareto-simulator


Where are we spending most time?


Two alternative approaches


⮯

Exercise +


Clone package pareto-simulator

$ git clone https://github.com/alexfernandez/pareto-simulator.git 
$ cd pareto-simulator

Install microprofiler 

$ npm i microprofiler

Read the instructions

⮯

Exercise +


Instrument the code:
const microprofiler = require('microprofiler');
...
	computeSamples() {
		for (let i = 0; i < options.number; i++) {
        	const start = microprofiler.start()
			const sample = this.computeSample()
			microprofiler.measureFrom(start, 'sample', 10000)
			this.samples.push(sample)
			this.sum += sample
			if (sample > this.max) this.max = sample
			if (sample < this.min) this.min = sample
			microprofiler.measureFrom(start, 'stats', 10000)
		}
	}

Run and see the results:
$ node index.js --xm 1 -n 1000 --parallel 30 --series 30 --timeout 10 --linear 

⮯

Exercise +


Now instrument the function computeSample()


Look for any surprises


Try to find some optimization...


And measure again

⮯

Exercise+


Now let's run the Node.js profiler:
$ node --prof index.js --xm 28 -n 10000000

And now check out the output:
$ node --prof-process isolate-0x...-v8.log

Is anything surprising?

Can you imagine how to improve it?

Is this profiler as agile as microprofiler?

⮯

Good job!


Bibliography





pinchito.es: Pruebas de carga

Node.js: Flame Graphs

Netflix Tech Blog: Node.js in Flames

Skeepers Influence Workshop: Statistics for Performance

By Alex Fernández

Skeepers Influence Workshop: Statistics for Performance

Skeepers Influence Workshop: Statistics for Performance. https://www.notion.so/Tech-Workshops-e89e98e8ae8b45b1b9063610740a3fba

  • 925

More from Alex Fernández