Yevhen Tatarynov "My .NET Application Allocates too Much Memory. What Can I Do?"

1. My .NET Application Allocates too Much
Memory
What Can I Do?
2020-10-20

2. 2www.luxoft.com
Yevhen Tatarynov
 Software developer with 14 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
 Point of professional interest:
 application performance optimization and analysis
 writing C# code similar in performance to C++
 advanced debugging
At Luxoft DXC, I work in the Gas & Oil and Financial domains.
Most of the projects involve performing complex mathematical
calculations and processing large amounts of data.

3. 3www.luxoft.com
AGENDA
1. What is the challenge?
2. Measurements
3. Too much…?
4. Summary
5. Demo
6. QA

4. 4www.luxoft.com
THE CHALLENGE

5. 5www.luxoft.com
CONSOLE .NET APPLICATION
 Read *.csv data files
 Process data in multiple threads
 Write results in MS Excel file
 Use .NET Framework 4.6.2
 Run on Windows
 It works correctly

6. 6www.luxoft.com
VIRTUAL ENVIRONMENT
 Windows 7 x64
 RAM – 8GB (including the 2 GB consumed by the OS)
 CPU – Intel Xeon CPU E5-2695 v4 @ 2.10GHz
 HDD – Unknown

7. 7www.luxoft.com
NON-FUNCTIONAL REQUIREMENTS
 We need to process 2 files > 1.5 GB , 2 files > 256MB, and 2 files >
5.5MB (the size of file will grow)
 Results needed every day at a specific time
 The virtual machine is shared by other data processing applications, so
we shouldn’t affect them.

8. 8www.luxoft.com
DISAPPOINTING FORECAST
File size Execution Time Peak memory
load
Total memory
allocation
~5.5 MB
~ 1 min. ~120 MB ~1,330 MB
~819MB ~21 min. ~6.12 GB
~419,570 MB
> 1.5 GB         

9. 9www.luxoft.com
WHAT IS THE CHALLENGE?
GOALS
 Smooth peak memory load
 Reduce total memory allocation
 Don’t break the application output
VALUES
 Fewer GC runs
 Less impact on other processes
 Processing finished in appropriate
time

10. 10www.luxoft.com
MEASUREMENTS

11. 11www.luxoft.com
MEASUREMENT TOOLS
1. DotNetBenchmark
2. Visual Studio Performance Profiler
3. Performance monitor
4. Perfview
5. R# dotTrace
6. R# dotMemory

12. 12www.luxoft.com

13. 13www.luxoft.com
dotMemory Snapshot

14. 14www.luxoft.com

15. 15www.luxoft.com
CHOOSE METRICS
PEAK MEMORY LOAD
 Unstable in multithread
 Depends on available free RAM
space
 GC runs
 Hard to reproduce
TOTAL MEMORY USAGE
 Stable in any use case
 Depends only on application logic
 Easy to reproduce

16. 16www.luxoft.com
TOO MUCH…?

17. 17www.luxoft.com
#1 TOO MANY CODE ISSUES?
 Unused variables
 Unused properties
 Unused objects not allocated
 Unused data not loaded from files
 Unused fields don’t increase
object size

18. 18www.luxoft.com
#1 MEMORY SNAPSHOT
Total memory old 419,750 MB
Total memory new 359,971 MB
Total memory diff -55,599 MB
Percent 14 %

19. 19www.luxoft.com
ConcurrentDictionary<MyKey,string>
public struct MyKey
{
string field1;
string field2;
/*.....*/
}
#2 TOO MANY KEYS?

20. 20www.luxoft.com
BOXING
ConcurrentDictionary<TKey,TValue> classes have the same functionality
as the Hashtable class. A ConcurrentDictionary <TKey,TValue> of a specific
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.

21. 21www.luxoft.com
StackOverflow
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.

22. 22www.luxoft.com
IEQUATABLE INTERFACE
public struct MyKey : IEquatable<MyKey>
{
string field1;
string field2;
string field3;
/*.....*/
public bool Equals(MyKey other);
}

23. 23www.luxoft.com
#2 MEMORY SNAPSHOT
Total memory old 359,971 MB
Total memory new 137,294 MB
Total memory diff -251,654 MB
Percent 65 %

24. 24www.luxoft.com
#3 REQUIREMENTS ARE CHANGED
Total memory old 137,294 MB
Total memory new 140,550 MB
Total memory diff +3,256 MB
Percent 2 %

25. 25www.luxoft.com
class MyClass<T>where T : struct
{
T Add(T a, T b) =>
(dynamic)a+(dynamic)b;
}
#4 TOO MUCH SYSTEM.DOUBLE IN HEAP?

26. 26www.luxoft.com
#4 DO WE NEED TO CAST TO DYNAMIC?
For Struct we have no defined
operation +, so to maintain generic
MyClass<T> we need to cast to
dynamic and we make boxing 
We use only double type for T
public class MyClass
{
double Add(double a,double b)
=> a + b;
}

27. 27www.luxoft.com
#4 MEMORY SNAPSHOT
Total memory old 140,550 MB
Total memory new 130,288 MB
Total memory diff -10,262 MB
Percent 7 %

28. 28www.luxoft.com
/* Collect full csv string */
all=new List<char>();
/* Unused Data */
raw=all.ToString();
postBack(raw);
#5 TOO MUCH Char[] & LIST<char>?

29. 29www.luxoft.com
#5 MEMORY SNAPSHOT
Total memory old 130,288 MB
Total memory new 59,565 MB
Total memory diff -70,723 MB
Percent 54 %

30. 30www.luxoft.com
/*
Collect single element of csv string
*/
item=new List<char>();
/*.....*/
return item.ToArray();
#6 STILL TOO MUCH Char[]?

31. 31www.luxoft.com
#6 REUSE StringBuilder
 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
Cache StringBuilder in private field
char[] item
_stringBuilder.Clear();
/*.....*/
_stringBuilder.Write(item);
return item;

32. 32www.luxoft.com
#6 MEMORY SNAPSHOT
Total memory old 59,565 MB
Total memory new 43,338 MB
Total memory diff -16,227 MB
Percent 27 %

33. 33www.luxoft.com
/*
Collect chars items to map them into data
model
*/
item=new List<Item>();
/*.....*/
Items.Add(new Item());
#7 TOO MUCH Item?

34. 34www.luxoft.com
#7 MEMORY SNAPSHOT
Total memory old 43,338 MB
Total memory new 36,274 MB
Total memory diff -7,064 MB
Percent 16 %

35. 35www.luxoft.com
item=new List<Item>();
/*.....*/
return Map(item.ToArray());
#8 TOO MUCH Item array

36. 36www.luxoft.com
#8 MEMORY SNAPSHOT
Total memory old 36,274 MB
Total memory new 34,243 MB
Total memory diff -2,031 MB
Percent 6 %

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

38. 38www.luxoft.com
#9 MEMORY SNAPSHOT
Total memory old 34,243 MB
Total memory new 33,118 MB
Total memory diff -1,125 MB
Percent 3 %

39. 39www.luxoft.com
/*Read single item of csv*/
_stringBuilder.Append();
/*Copy collected chars into array*/
item = new char[n];
/*.....*/
return item;
#10 TOO MUCH Char[]?

40. 40www.luxoft.com
#10 Array.Pool<T> ?
_stringBuilder.Append();
/*.....*/
var item = ArrayPool<char>().Shared.Rent(n);
/*.....*/
return item;
/*.....*/
ArrayPool<char>().Shared.UnRent(item);

41. 41www.luxoft.com
#10 MEMORY SNAPSHOT
Total memory old 33,118 MB
Total memory new 28,504 MB
Total memory diff -4,614 MB
Percent 14 %

42. 42www.luxoft.com
string Convert(char[] items)
=> return new string(items)
#11 TOO MANY Strings?

43. 43www.luxoft.com
#11 CACHE PAIR STRING & Char[]
var dict = new ConcurrentDictionary<CacheKey, string>();
struct CacheKey : IEquatable<CacheKey>
{
private char[] _value;
private int _length;
public bool Equals(CacheKey other)
public override int GetHashCode()
}

44. 44www.luxoft.com
#11 MEMORY SNAPSHOT
Total memory old 28,504 MB
Total memory new 25,587 MB
Total memory diff -2,917 MB
Percent 10 %

45. 45www.luxoft.com
Because it is:
name = value.ToUpper(),
But we can’t remove it without having an impact
on results. 
#12 DO WE NEED Strings?

46. 46www.luxoft.com
PropertyInfo
propertyInfo.SetValue(obj, value);
/*.....*/
#13 TOO MUCH Object[]

47. 47www.luxoft.com
FieldInfo fieldInfo
fieldInfo.SetValue(obj, value);
/*.....*/
#13 FieldInfo

48. 48www.luxoft.com
#13 MEMORY SNAPSHOT
Total memory old 25,587 MB
Total memory new 18,762 MB
Total memory diff -6,825 MB
Percent 27 %

49. 49www.luxoft.com
void MyType[] GetArray()
=>_cache.Order().ToArray();
/*.....*/
var a = GetArray();
a.Distinct();
#14 TOO MUCH ARRAY

50. 50www.luxoft.com
# 14 GetOrAdd vs. TryGetValue
public ValueClass GetValue(string name)
{
var val = null;
if (!_dict.TryGetValue(name, out val))
{
_cache.Add(name);
value = new ValueClass(name);
_dict.TryAdd(myKey, storedValue);
}
return val;
}
public ValueClass GetValue(string
name)
{
var val = new ValueClass(name);
_cache.Add(name);
return _dict.GetOrAdd(name, val);
}

51. 51www.luxoft.com
#14 MEMORY SNAPSHOT
Total memory old 18,762 MB
Total memory new 15,852 MB
Total memory diff -2,910 MB
Percent 16 %

52. 52www.luxoft.com
#15 GetOrAdd GLOBAL REFACTORING
public ValueClass GetValue(string name)
{
var value = null;
if (!_dict.TryGetValue(name, out
value))
{
value = new ValueClass(name);
_dict.TryAdd(myKey, storedValue);
}
return value;
}
public ValueClass GetValue(string
name)
{
var value = new ValueClass(name);
return _dict.GetOrAdd(name,
value);
}

53. 53www.luxoft.com
#15 MEMORY SNAPSHOT
Total memory old 15,852 MB
Total memory new 12,815 MB
Total memory diff -3,037 MB
Percent 19 %

54. 54www.luxoft.com
SUMMARY

55. 55www.luxoft.com
dotMemory Snapshot

56. 56www.luxoft.com
PEAK MEMORY LOAD
Peak memory load old 6.12 GB
Peak memory load
new
4.31 GB
Peak memory load
diff
-1.81 GB
Percent ~30 %
Ratio ~1.41

57. 57www.luxoft.com

58. 58www.luxoft.com
TOTAL MEMORY USAGE
Total memory usage
old
419,570 MB
Total memory usage
new
12.815 MB
Total memory usage
diff
-406.755 MB
Percent ~97 %
Ratio ~32.74

59. 59www.luxoft.com
EXECUTION TIME
Execution time old ~21 m
Execution time
new
~9 m
Execution time
diff
-12 m
Percent ~57 %
Ratio ~2.33

60. 60www.luxoft.com

61. 61www.luxoft.com
SUMMARY
 Keep your code clean
 Avoid Boxing
 Reuse / cache object (ArrayPool)
 Use StringBuilder when you work with chars and strings
 Avoid string operations (concatenation, ToUpper, etc.)
 Use lambdas carefully
 Don’t allocate memory for useless data 

62. 62www.luxoft.com
DEMO

63. Thank You!

64. 64www.luxoft.com
Q&A

65. 65www.luxoft.com
LINKS
 Use dotTrace Command-Line Profiler
 .NET Performance Optimization & Profiling with JetBrains dotTrace
 Use dotMemory Command-Line Profiler
 "Pooling large arrays with ArrayPool" Adam Sitnik
 Hashtable and dictionary collection types
 Why GC run when using a struct as a generic dictionary
 Matt Ellis. Writing Allocation Free Code in C#
 Konrad Kokosa. High-performance code design patterns in C#

66. 66www.luxoft.com
Links
 Maarten Balliauw. Let’s refresh our memory! Memory management in
.NET
 Konrad Kokosa. Pro .NET Memory Management: For Better Code,
Performance, and Scalability
 Sasha Goldshtein. Pro .NET Performance: Optimize Your C#
Applications
 Ben Watson. Writing High-Performance .NET Code, 2nd Edition
 Maarten Balliauw
 Sasha Goldshtein
 Yevhen Tatarynov GitHub