"Optimization of a .NET application- is it simple ! / ?", Yevhen Tatarynov

Yevhen Tatarynov
Software developer with 15 years of experience in commercial
software and database development (.NET / MS SQL / Delphi)
PhD in math, specializing in the theoretical foundations of
computer science and cybernetics
I was involved in projects performing complex mathematical calculations and processing large
amounts of data. For now my role senior software developer in infrastructure team, Covent IT.
Point of professional interest:
application performance optimization and analysis
writing C# code similar in performance to C++
advanced debugging

Agenda
The ﬁrst
challenge?
Measurements To much … ?
Summary
QA
The second
challenge?
Is It an
bottleneck?
Measurements

Console .NET application
Read *.csv data ﬁles
Process data in
multiple threads
Write results in MS
Excel ﬁle
Use .NET Framework
4.6.2 Run on Windows It works correctly

Measurement Tools
DotNetBenchmark
Visual Studio
Performance Proﬁler
Perfview R# dotTrace R# dotMemory
Performance
monitor

# Too many code issues?
Unused variables
Unused properties
Unused objects not allocated
Unused data not loaded from ﬁles
Unused ﬁelds don’t increase object
size

# Memory snapshot
Total memory old
Total memory new
Total memory diff
Percent
419,750 MB
359,971 MB
14 %
-55,599 MB

# Too many keys
ConcurrentDictionary<MyKey,string>
public struct MyKey
{
string field1;
string field2;
/*.....*/
}

Boxing
ConcurrentDictionary<TKey,TValue> classes have the same
functionality as the Hashtable class. A ConcurrentDictionary
<TKey,TValue> of a speciﬁc type (other than Object) provides
better performance than a Hashtable for value types.
This is because the elements of Hashtable are of type Object;
therefore, boxing and unboxing typically occur when you store
or retrieve a value type.

StackOverﬂow
Since you only override Equals and don’t implement
IEquatable<T>, the dictionary is forced to box one of the two
instances whenever it compares two of them for equality
because it's passing an instance into an
Equals-method-accepting object.
If you implement IEquatable<T>, then the dictionary can (and
will) use the version of Equals that accepts the parameter as a
T, which won't require boxing.

IEquatable interface
public struct MyKey : IEquatable<MyKey>
{
string field1;
string field2;
string field3;
/*.....*/
public bool Equals(MyKey other);
}

# Memory snapshot
Total memory old
Total memory new
Total memory diff
Percent
359,971 MB
137,294 MB
65 %
-251,654 MB

# Too much System.Double in heap?
class MyClass<T> where T : struct
{
T Add(T a, T b) =>
(dynamic)a+(dynamic)b;
}

We use only double type for T
class MyClass
{
double Add(double a, double b)
=> a + b;
}
For Struct we have no deﬁned operation
+, so to maintain generic MyClass<T> we
need to cast to dynamic and we make
boxing ☹
We use only double type for T

# Memory snapshot
Total memory old
Total memory new
Total memory diff
Percent
140,550 MB
130,288 MB
7 %
-10,262 MB

# Still too much char[ ]?
/*
Collect single element of csv
string
*/
item=new List<char>();
/*.....*/
return item.ToArray();

# REUSE StringBuilder
char[] item
_stringBuilder.Clear();
/*.....*/
_stringBuilder.Write(item);
return item;
Cache StringBuilder in private ﬁeld
No new Allocation
Can be used for different item
lengths
Can grow in 8,000 bytes if it’s
necessary to expand the internal buffer

# Memory snapshot
Total memory old
Total memory new
Total memory diff
Percent
59,565 MB
43,338 MB
27 %
-16,227 MB

# TOO MUCH <>c_DisplayClass26_0?
void AddValue(string key,string val)
/* Redundant lambda all data read
only */
dict.TryAdd(key,()=>new Data(val));
/*.....*/

# Memory snapshot
Total memory old
Total memory new
Total memory diff
Percent
34,243 MB
33,118 MB
3 %
-1,125 MB

WinForms .NET Applications
Read *.bin, *.txt data
ﬁles
“Process bits”, extract
and use full data, pack
into new format
It works correctly
Write results in text
and binary ﬁles
Use .NET
Framework 4.0
Run on Windows 10 x64

dotTrace TimeLine Sample & Snapshot Execution Time

Potential Improvements
Used .ToArray() - slow
Concat use foreach and extra
memory to iterate input params
Each time we produce new byte array.
Redundant memory trafﬁc.
var b = new byte[];
for (int i = 0; i < N; i++)
{
byte[] a = new byte[GetLen(i)];
/* fill a with values */
b = b.Concat(a).ToArray();
}
return b;

Buffer.BlockCopy
public static void BlockCopy
(Array src, int srcOffset, Array
dst, int dstOffset,
int count);
Copies a speciﬁed number of bytes from a
source array starting at a particular offset to a
destination array starting at a particular offset.
● src – Array The source buffer.
● srcOffset - Int32 The
zero-based byte offset into src.
● dst – Array The destination
buffer.
● dstOffset - Int32 The
zero-based byte offset into
dst.
● count - Int32 The number of
bytes to copy.

Comparison
var b = new byte[];
for (int i = 0; i < N; i++)
{
byte[] a = new byte[GetLen(i)];
b = b.Concat(a).ToArray();
}
return b;
var b = new byte[maxN]; var bN=0;
for (int i = 0; i < N; i++)
{
var aN = GetLen(i);
byte[] a = new byte[aN];
Buffer.BlockCopy(aN,0,b,bN,aN);
bN += aN;
}
return b;

#1 Performance Summary
Execution time
1st 374,011
120,333
68,83 %
-38 m 25 s 228 ms
Memory (MB)
2nd
Diff
%
43 m 21 s 642 ms
4 m 56 s 414 ms
-253,678
88,61 %
х 3,11
х 9,25

# Is FileStream.get_Length an bottleneck?
In both cases, the binary ﬁle read and
the basis on read data is the
calculated number of binary chains.

using(var br = new BinaryReader(…))
{
while (br.BaseStream.Position <= br.BaseStream.Length - 4)
{
counter++;
br.ReadUInt32();
br.ReadUInt32();
var n = br.ReadUInt32();
for (int i = 0; i < n; i++) br.ReadUInt32();
}
}
Redundant Length calls
Redundant subtraction
Redundant call
ReadUInt32

Solution
{
var length = br.BaseStream.Length - 4;
while (br.BaseStream.Position <= length)
{
counter++;
br.ReadUInt64();
}
}
Store Length in local
variable
Call ReadUInt64 instead
ReadUInt32

Comparison
{
while (br.BaseStream.Position <= br.BaseStream.Length - 4)
{
counter++;
br.ReadUInt32();
br.ReadUInt32();
}
}
{
var length = br.BaseStream.Length - 4;
while (br.BaseStream.Position <= length)
{
counter++;
br.ReadUInt64();
}
}

# Performance Summary
Execution time
Old 103,775
103,775
0.00 %
-31 s 786 ms
Memory (MB)
New
Diff
%
2 m 11 s 091 ms
1 m 39 s 305 ms
0
24.25 %
х 1.00
х 1.32

# ScaleGrad. - Can It Be Faster?
/*
Return index of number x by ordered
scale
*/
int ScaleGrad(int x)

static double[] Scale;
…
/* 600+ lines of code */
…
{
for(int i=0; i<Scale.Length && Scale[i]<=x; i++)
return i - 1;
}
Avoid compare int and
double values
Scale is a sorted array, so
we can use binary search;
it’s more efﬁcient and less
dependent on input data

Comparison
static double[] Scale;
/* 600+ lins of code */
{
for(int i=0;(i<Scale.Length)&&(Scale[i]<= x);i++);
return i - 1;
}
static int[] Scale;
/* 600+ lins of code */
var left = 1; var right = Scale.Length -1;
var mid =(left + right)>>1;//(left+right)/2
do {
mid = left + ((right - left)>>1);
if ( x < Scale[mid]) right = mid - 1;
else left = mid + 1;
} while (right >= left);
return mid;

#9 Performance Summary
Execution time
Old 9,754
9,754
0.00 %
-3 s 707 ms
Memory (MB)
New
Diff
%
32 s 551 ms
28 s 844 ms
0
11.39 %
х 1.00
х 1.13

PLEASE JOIN OUR WORKSHOP
TO SEE ALL OPTIMIZATION STEPS

LINKS
Use dotTrace Command-Line Proﬁler Hashtable and dictionary collection types
.NET Performance Optimization &
Proﬁling with JetBrains dotTrace
Why GC run when using a struct as a
generic dictionary
Matt Ellis. Writing Allocation Free Code
in C#
Maarten Balliauw. Let’s refresh our
memory! Memory management in .NET
Sasha Goldshtein. Pro .NET Performance:
Optimize Your C# Applications
Ben Watson. Writing High-Performance
.NET Code, 2nd Edition

Maarten Balliauw
LINKS
Sasha Goldshtein
Yevhen Tatarynov GitHub
Writing Faster Managed Code: Know
What Things Cost
Ling.Concat
Linq.Concat Implementation
Buffer.BlockCopy
Generic List implementation
Konrad Kokosa. High-performance code
design patterns in C#

"Optimization of a .NET application- is it simple ! / ?", Yevhen Tatarynov

More Related Content

Similar to "Optimization of a .NET application- is it simple ! / ?", Yevhen Tatarynov (20)

More from Fwdays (20)

Recently uploaded (20)

"Optimization of a .NET application- is it simple ! / ?", Yevhen Tatarynov