Распространённые ошибки оценки производительности .NET-приложений

Распространённые ошибки оценки производительности
.NET-приложений
Андрей Акиньшин, JetBrains
SPB .NET Meetup #6
1/48

Часть 1
Теория
2/48 Теория

Поговорим про бенчмарки
c Wikipedia
c Aleksey Shipil¨ev
3/48 Теория

План работ
1 Поставить задачу
2 Выбрать метрики
3 Выбрать инструмент
4 Провести эксперимент
5 Выполнить анализ, сделать выводы
4/48 Теория

Окружение
• C#-компилятор: версия старого csc? Roslyn?
• Версия CLR: CLR2? CLR4? CoreCLR? Mono?
• Версия ОС: Windows? Linux? MacOS? FreeBSD?
• Версия JIT: x86? x64? RyuJIT?
• Версия GC: MS (какой CLR?)? Mono (Boehm/Sgen)?
• Компиляция: JIT? NGen? .NET Native?
• Железо: ???
• ...
5/48 Теория

Запуск бенчмарка
• Release build
• Без дебаггера
• Выключите другие приложения
• Используйте максимальную
производительность
6/48 Теория

DateTime vs Stopwatch
var start = DateTime.Now;
Foo();
var finish = DateTime.Now;
Console.WriteLine((finish - start).Milliseconds);
vs
var sw = Stopwatch.StartNew();
Foo();
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
7/48 Теория

DateTime vs Stopwatch
var start = DateTime.Now;
Foo();
var finish = DateTime.Now;
Console.WriteLine((finish - start).Milliseconds);
vs
Foo();
sw.Stop();
Возможные значения (Windows 10, MS.NET, Core i7):
Granularity Latency
DateTime 1 000 000 ns∗
30–40 ns
Stopwatch 370–466 ns 14–18 ns
7/48 Теория

Итерации
Плохо:
// Granularity(Stopwatch) = 466 ns
// Latency(Stopwatch) = 18 ns
Foo(); // 100 ns
sw.Stop();
8/48 Теория

Итерации
Плохо:
// Granularity(Stopwatch) = 466 ns
// Latency(Stopwatch) = 18 ns
Foo(); // 100 ns
sw.Stop();
Лучше:
for (int i = 0; i < N; i++) // (N * 100 + eps) ns
Foo();
sw.Stop();
var total = sw.ElapsedTicks / Stopwatch.Frequency;
Console.WriteLine(total / N);
8/48 Теория

Прогрев
Запустим бенчмарк несколько раз:
int[] x = new int[128 * 1024 * 1024];
for (int iter = 0; iter < 5; iter++)
{
for (int i = 0; i < x.Length; i += 16)
x[i]++;
sw.Stop();
}
9/48 Теория

Прогрев
Запустим бенчмарк несколько раз:
int[] x = new int[128 * 1024 * 1024];
for (int iter = 0; iter < 5; iter++)
{
for (int i = 0; i < x.Length; i += 16)
x[i]++;
sw.Stop();
}
Результат:
176
81
62
62
62
9/48 Теория

Несколько запусков бенчмарка
Run 01 : 529.8674 ns/op
Run 02 : 532.7541 ns/op
Run 03 : 558.7448 ns/op
Run 04 : 555.6647 ns/op
Run 05 : 539.6401 ns/op
Run 06 : 539.3494 ns/op
Run 07 : 564.3222 ns/op
Run 08 : 551.9544 ns/op
Run 09 : 550.1608 ns/op
Run 10 : 533.0634 ns/op
10/48 Теория

Несколько запусков CLR
11/48 Теория

Статистика
12/48 Теория

Накладные расходы
int x = 0;
for (int i = 0; i < N; i++) // overhead
x++; // target operation
sw.Stop();
13/48 Теория

Изоляция бенчмарков
Плохо:
Measure1();
Measure2();
14/48 Теория

Изоляция бенчмарков
Плохо:
Measure1();
Measure2();
Вспомним про:
• Interface method dispatch
• Garbage collector
14/48 Теория

Борьба с оптимизациями
• Dead code elimination
• Inlining
• Constant folding
• Instruction Level Parallelism
• Branch prediction
• ...
15/48 Теория

Организация доступа к памяти
Event Latency Scaled
1 CPU cycle 0.3 ns 1 s
Level 1 cache access 0.9 ns 3 s
Main memory access 120 ns 6 min
Solid-state disk I/O 50-150 µs 2-6 days
Rotational disk I/O 1-10 ms 1-12 months
Internet: SF to NYC 40 ms 4 years
Internet: SF to UK 81 ms 8 years
Internet: SF to Australia 183 ms 19 years
OS virtualization reboot 4 s 423 years
SCSI command time-out 30 s 3000 years
Hardware virtualization reboot 40 s 4000 years
Physical system reboot 5 m 32 millenia
c Systems Performance: Enterprise and the Cloud
16/48 Теория

Processor aﬃnity
17/48 Теория

Многопоточные бенчмарки сложны
False sharing:
c http://colfaxresearch.com/optimization-techniques-for-the-intel-mic-architecture-
part-3-of-3-false-sharing-and-padding/
18/48 Теория

False sharing в действии
private static int[] x = new int[1024];
private void Inc(int p)
{
for (int i = 0; i < 10000001; i++)
x[p]++;
}
private void Run(int step)
{
Task.WaitAll(
Task.Factory.StartNew(() => Inc(0 * step)),
Task.Factory.StartNew(() => Inc(3 * step)));
}
19/48 Теория

False sharing в действии
private static int[] x = new int[1024];
private void Inc(int p)
{
for (int i = 0; i < 10000001; i++)
x[p]++;
}
private void Run(int step)
{
Task.WaitAll(
Task.Factory.StartNew(() => Inc(3 * step)));
}
Run(1) Run(256)
∼400 ∼150
19/48 Теория

BenchmarkDotNet
20/48 Теория

BenchmarkDotNet
v0.7.8:
• Создание отдельного проекта для каждого бенчмарка
• Запуск под разными окружениями
• Прогрев, многократный запуск, статистики
• Анализ накладных расходов
• И много чего ещё...
21/48 Теория

BenchmarkDotNet
v0.7.8:
• Создание отдельного проекта для каждого бенчмарка
• Запуск под разными окружениями
• Прогрев, многократный запуск, статистики
• Анализ накладных расходов
• И много чего ещё...
В следующих сериях:
• Просмотр IL и ASM
• Графики
• Поддержка CoreCLR/.NET Native
• Многопоточные бенчмарки
21/48 Теория

Часть 2
Практика
22/48 Практика

Сумма элементов массива
const int N = 1024;
int[,] a = new int[N, N];
[Benchmark]
public double SumIj()
{
var sum = 0;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
sum += a[i, j];
return sum;
}
[Benchmark]
public double SumJi()
{
var sum = 0;
for (int j = 0; j < N; j++)
for (int i = 0; i < N; i++)
sum += a[i, j];
return sum;
}

Сумма элементов массива
const int N = 1024;
int[,] a = new int[N, N];
[Benchmark]
public double SumIj()
{
var sum = 0;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
sum += a[i, j];
return sum;
}
[Benchmark]
public double SumJi()
{
var sum = 0;
for (int j = 0; j < N; j++)
for (int i = 0; i < N; i++)
sum += a[i, j];
return sum;
}
SumIj SumJi
LegacyJIT-x86 1 попугай 3.5 попугая

Структуры данных
Binary Search

Структуры данных
Cache-Conscious Binary Search

Branch prediction
const int N = 32767;
int[] sorted, unsorted; // random numbers [0..255]
private static int Sum(int[] data)
{
int sum = 0;
for (int i = 0; i < N; i++)
if (data[i] >= 128)
sum += data[i];
return sum;
}
[Benchmark]
public int Sorted()
{
return Sum(sorted);
}
[Benchmark]
public int Unsorted()
{
return Sum(unsorted);
}

Branch prediction
const int N = 32767;
int[] sorted, unsorted; // random numbers [0..255]
private static int Sum(int[] data)
{
int sum = 0;
for (int i = 0; i < N; i++)
if (data[i] >= 128)
sum += data[i];
return sum;
}
[Benchmark]
public int Sorted()
{
return Sum(sorted);
}
[Benchmark]
public int Unsorted()
{
return Sum(unsorted);
}
Sorted Unsorted

Интерфейсы
private interface IFoo {
double Inc(double x);
}
private class Foo1 : IFoo {
public double Inc(double x) =>
x + 1;
}
x + 1;
}
private double Run(IFoo foo) {
double sum = 0;
for (int i = 0; i < 1001; i++)
sum += foo.Inc(0);
return sum;
}
[Benchmark]
public double Run11() {
var bar1 = new Foo1();
return Run(bar1) + Run(bar2);
}
[Benchmark]
}

Интерфейсы
private interface IFoo {
double Inc(double x);
}
x + 1;
}
x + 1;
}
private double Run(IFoo foo) {
double sum = 0;
for (int i = 0; i < 1001; i++)
sum += foo.Inc(0);
return sum;
}
[Benchmark]
}
[Benchmark]
}
Run11 Run12

История

Inlining
// mscorlib/system/decimal.cs,158
// Constructs a Decimal from an integer value.
public Decimal(int value) {
// JIT today can’t inline methods that contains "starg"
// opcode. For more details, see DevDiv Bugs 81184:
// x86 JIT CQ: Removing the inline striction of "starg".
int value_copy = value;
if (value_copy >= 0) {
flags = 0;
}
else {
flags = SignMask;
value_copy = -value_copy;
}
lo = value_copy;
mid = 0;
hi = 0;
}

Inlining
[Benchmark]
int Calc() => WithoutStarg(0x11) + WithStarg(0x12);
int WithoutStarg(int value) => value;
int WithStarg(int value)
{
if (value < 0)
value = -value;
return value;
}

Inlining
[Benchmark]
int Calc() => WithoutStarg(0x11) + WithStarg(0x12);
int WithoutStarg(int value) => value;
int WithStarg(int value)
{
if (value < 0)
value = -value;
return value;
}
LegacyJIT-x86 LegacyJIT-x64 RyuJIT-x64
1 попугай 0 попугаев 1 попугай

Как же так?
LegacyJIT-x64
; LegacyJIT-x64
mov ecx,23h
ret

Как же так?
LegacyJIT-x64
; LegacyJIT-x64
mov ecx,23h
ret
RyuJIT-x64
// Inline expansion aborted due to opcode
// [06] OP_starg.s in method
// Program:WithStarg(int):int:this

История

Поговорим про Readonly ﬁelds
public struct Int256
{
private readonly long bits0, bits1, bits2, bits3;
public Int256(long bits0, long bits1, long bits2, long bits3)
{
this.bits0 = bits0; this.bits1 = bits1;
}
public long Bits0 => bits0; public long Bits1 => bits1;
}
private Int256 a = new Int256(1L, 5L, 10L, 100L);
private readonly Int256 b = new Int256(1L, 5L, 10L, 100L);
[Benchmark] public long GetValue() =>
a.Bits0 + a.Bits1 + a.Bits2 + a.Bits3;
[Benchmark] public long GetReadOnlyValue() =>
b.Bits0 + b.Bits1 + b.Bits2 + b.Bits3;

Поговорим про Readonly ﬁelds
public struct Int256
{
private readonly long bits0, bits1, bits2, bits3;
public Int256(long bits0, long bits1, long bits2, long bits3)
{
}
}
private Int256 a = new Int256(1L, 5L, 10L, 100L);
private readonly Int256 b = new Int256(1L, 5L, 10L, 100L);
[Benchmark] public long GetValue() =>
a.Bits0 + a.Bits1 + a.Bits2 + a.Bits3;
[Benchmark] public long GetReadOnlyValue() =>
b.Bits0 + b.Bits1 + b.Bits2 + b.Bits3;
LegacyJIT-x64 RyuJIT-x64
GetValue 1 попугай 1 попугай
GetReadOnlyValue 6.2 попугая 7.6 попугая

Как же так?
; GetValue
IL_0000: ldarg.0
IL_0001: ldflda valuetype Program::a
IL_0006: call instance int64 Int256::get_Bits0()
; GetReadOnlyValue
IL_0000: ldarg.0
IL_0001: ldfld valuetype Program::b
IL_0006: stloc.0
IL_0007: ldloca.s 0
IL_0009: call instance int64 Int256::get_Bits0()
См. также: Jon Skeet, Micro-optimization: the surprising ineﬃciency of readonly ﬁelds

Поговорим про SIMD
private struct MyVector
{
public float X, Y, Z, W;
public MyVector(float x, float y, float z, float w)
{
X = x; Y = y; Z = z; W = w;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MyVector operator *(MyVector left, MyVector right)
{
return new MyVector(left.X * right.X, left.Y * right.Y,
left.Z * right.Z, left.W * right.W);
}
}
private Vector4 vector1, vector2, vector3;
private MyVector myVector1, myVector2, myVector3;
[Benchmark] public void MyMul() => myVector3 = myVector1 * myVector2;
[Benchmark] public void BclMul() => vector3 = vector1 * vector2;

Поговорим про SIMD
private struct MyVector
{
public float X, Y, Z, W;
public MyVector(float x, float y, float z, float w)
{
X = x; Y = y; Z = z; W = w;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MyVector operator *(MyVector left, MyVector right)
{
return new MyVector(left.X * right.X, left.Y * right.Y,
left.Z * right.Z, left.W * right.W);
}
}
private Vector4 vector1, vector2, vector3;
private MyVector myVector1, myVector2, myVector3;
[Benchmark] public void MyMul() => myVector3 = myVector1 * myVector2;
[Benchmark] public void BclMul() => vector3 = vector1 * vector2;
MyMul 34 попугая 5 попугаев
BclMul 34 попугая 1 попугай

Как же так?
; LegacyJIT-x64
; MyMul, BclMul
; ...
movss xmm3,dword ptr [rsp+40h]
mulss xmm3,dword ptr [rsp+30h]
movss xmm0,dword ptr [rsp+4Ch]
mulss xmm0,dword ptr [rsp+3Ch]
xor eax,eax
mov qword ptr [rsp],rax
mov qword ptr [rsp+8],rax
lea rax,[rsp]
movss dword ptr [rax],xmm3
movss dword ptr [rax+4],xmm2
movss dword ptr [rax+8],xmm1
movss dword ptr [rax+0Ch],xmm0
; ...
; RyuJIT-x64
; MyMul
; ...
vmulss xmm0,xmm0,xmm4
; ...
; BclMul
vmovupd xmm0,xmmword ptr [rcx+8]
vmovupd xmm1,xmmword ptr [rcx+18h]
vmulps xmm0,xmm0,xmm1
vmovupd xmmword ptr [rcx+28h],xmm0

Думаем про ASM
double x = /* ... */ ;
double a = x + 1;
double b = x * 2;
double c = Math.Sqrt(x);

Думаем про ASM
double x = /* ... */ ;
double a = x + 1;
double b = x * 2;
double c = Math.Sqrt(x);
LegacyJIT-x86 LegacyJIT-x64 RyuJIT-x64
(x87 FPU) (SSE2) (AVX)
x + 1 faddp addsd vaddsd
x * 2 fmul mulsd vmulsd
Sqrt(X) fsqrt sqrtsd vsqrtsd

История

Задачка
double Sqrt13() =>
Math.Sqrt(1) + Math.Sqrt(2) + Math.Sqrt(3) + /* ... */
+ Math.Sqrt(13);
VS
double Sqrt14() =>
+ Math.Sqrt(13) + Math.Sqrt(14);

Задачка
double Sqrt13() =>
+ Math.Sqrt(13);
VS
double Sqrt14() =>
+ Math.Sqrt(13) + Math.Sqrt(14);
RyuJIT-x641
Sqrt13 40 попугаев
Sqrt14 1 попугай
1
RyuJIT RC

Как же так?
RyuJIT-x64, Sqrt13
vsqrtsd xmm0,xmm0,mmword ptr [7FF94F9E4D28h]
vaddsd xmm0,xmm0,xmm1
ret

Как же так?
RyuJIT-x64, Sqrt14
vmovsd xmm0,qword ptr [7FF94F9C4C80h]
ret

Как же так?
Constant folding в действии
N001 [000001] dconst 1.0000000000000000 => $c0 {DblCns[1.000000]}
N002 [000002] mathFN => $c0 {DblCns[1.000000]}
N003 [000003] dconst 2.0000000000000000 => $c1 {DblCns[2.000000]}
N004 [000004] mathFN => $c2 {DblCns[1.414214]}
N005 [000005] + => $c3 {DblCns[2.414214]}
N006 [000006] dconst 3.0000000000000000 => $c4 {DblCns[3.000000]}
N007 [000007] mathFN => $c5 {DblCns[1.732051]}
N008 [000008] + => $c6 {DblCns[4.146264]}
N009 [000009] dconst 4.0000000000000000 => $c7 {DblCns[4.000000]}
N010 [000010] mathFN => $c1 {DblCns[2.000000]}
N011 [000011] + => $c8 {DblCns[6.146264]}
N012 [000012] dconst 5.0000000000000000 => $c9 {DblCns[5.000000]}
N013 [000013] mathFN => $ca {DblCns[2.236068]}
N014 [000014] + => $cb {DblCns[8.382332]}
N015 [000015] dconst 6.0000000000000000 => $cc {DblCns[6.000000]}
N016 [000016] mathFN => $cd {DblCns[2.449490]}
N017 [000017] + => $ce {DblCns[10.831822]}
N018 [000018] dconst 7.0000000000000000 => $cf {DblCns[7.000000]}
N019 [000019] mathFN => $d0 {DblCns[2.645751]}
N020 [000020] + => $d1 {DblCns[13.477573]}
...

История

Задачка
private double[] x = new double[11];
[Benchmark]
public double Calc()
{
double sum = 0.0;
for (int i = 1; i < x.Length; i++)
sum += 1.0 / (i * i) * x[i];
return sum;
}

Задачка
private double[] x = new double[11];
[Benchmark]
public double Calc()
{
double sum = 0.0;
for (int i = 1; i < x.Length; i++)
sum += 1.0 / (i * i) * x[i];
return sum;
}
Calc 1 попугай 2 попугая
1
RyuJIT RC

Как же так?
; LegacyJIT-x64
; eax = i
mov eax,r8d
; eax = i*i
imul eax,r8d
; xmm0=i*i
cvtsi2sd xmm0,eax
; xmm1=1
movsd xmm1,
mmword ptr [7FF9141145E0h]
; xmm1=1/(i*i)
divsd xmm1,xmm0
; xmm1=1/(i*i)*x[i]
mulsd xmm1,
mmword ptr [rdx+r9+10h]
; xmm1 = sum + 1/(i*i)*x[i]
addsd xmm1,xmm2
; sum = sum + 1/(i*i)*x[i]
movapd xmm2,xmm1
; RyuJIT-x64
; r8d = i
mov r8d,eax
; r8d = i*i
imul r8d,eax
; xmm1=i*i
vcvtsi2sd xmm1,xmm1,r8d
; xmm2=1
vmovsd xmm2,
qword ptr [7FF9140E4398h]
; xmm2=1/(i*i)
vdivsd xmm2,xmm2,xmm1
mov r8,rdx
movsxd r9,eax
; xmm1 = 1/(i*i)
vmovaps xmm1,xmm2
; xmm1 = 1/(i*i)*x[i]
vmulsd xmm1,xmm1,
mmword ptr [r8+r9*8+10h]
; sum += 1/(i*i)*x[i]
См. также: https://github.com/dotnet/coreclr/issues/993

Методическая литература
Для успешных микрооптимизаций нужно очень много знать:
47/48

Вопросы?
Андрей Акиньшин
http://aakinshin.net
https://github.com/AndreyAkinshin
https://twitter.com/andrey_akinshin
andrey.akinshin@gmail.com
48/48

Распространённые ошибки оценки производительности .NET-приложений

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

En vedette

En vedette (17)

Similaire à Распространённые ошибки оценки производительности .NET-приложений

Similaire à Распространённые ошибки оценки производительности .NET-приложений (20)

Plus de Mikhail Shcherbakov

Plus de Mikhail Shcherbakov (20)

Распространённые ошибки оценки производительности .NET-приложений