Implemention low latency applications in C#

1. –

3. …

17. ’

19. Latency
Throughput

20. /

29. Latency Mystery series

35. 0
50 000 000
100 000 000
150 000 000
200 000 000
250 000 000
300 000 000
350 000 000
400 000 000
450 000 000
500 000 000
1 thread no lock 1 thread with lock
ops/s per thread
2ns

36. 0
50 000
100 000
150 000
200 000
250 000
1 thread
no lock
1 thread
with lock
2 threads 3 threads 4 threads 5 threads
ops/s per thread global ops/s
5µs

37. 0
2 000 000
4 000 000
6 000 000
8 000 000
10 000 000
12 000 000
1 thread 2 threads 3 threads 4 threads 5 threads
99 99,5 99,99 99,999 max
5µs

40. ”
“

42. Cache
Cache
CORE 0 Thread A
CPU
Memory
CORE 1 Thread B

43. Cache
Cache
CORE 0 Thread A
CPU
Memory
CORE 1

44. Cache
Cache
CORE 0
CPU
Memory
CORE 1 Thread B

45. Cache
Cache
CORE 0 Thread A
CPU
Memory
CORE 1 Thread B

46. Cache
Cache
CORE 0 Thread A
CPU
Memory
CORE 1 Thread B

47. Cache
Cache
CORE 0 Thread A
CPU
Memory
CORE 1 Thread B

48. ’

54. ’

56. “

59. List<int> list = new List<int>();
foreach (var i in list)
{
// Do something
}
IList<int> list = new List<int>();
foreach (var i in list)
{
// Do something
}

60. public Enumerator GetEnumerator()
{
// Enumerator is a struct
return new Enumerator(this);
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return new Enumerator(this); // boxing
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator(this); // boxing
}

61. struct Cucumber: IDisposable
{
void Dispose()
{
}
}

62. Var c = new Cucumber();
c.Dispose();
IL_0000: ldloca.s c
IL_0002: initobj Cucumber
IL_0008: ldloca.s c
IL_000a: call instance void Cucumber::Dispose()

63. Idisposable c = new Cucumber();
c.Dispose();
IL_0000: ldloca.s CS$0$0000
IL_0002: initobj Cucumber
IL_0008: ldloc.1
IL_0009: box Cucumber
IL_000e: stloc.0
IL_000f: ldloc.0
IL_0010: callvirt instance void IDisposable::Dispose()

64. using(var c = new Cucumber())
{
}
IL_0000: ldloca.s c
IL_0002: initobj Cucumber
.try {
IL_0008: leave.s IL_0018
} finally {
IL_000a: ldloca.s c
IL_000c: constrained. Cucumber
IL_0012: callvirt instance void IDisposable::Dispose()
IL_0017: endfinally
}

65. void DoSomething(IDisposable arg)
void DoSomething<T>(T arg) where T : IDisposable

66. *

67. [StructLayout(LayoutKind.Sequential)]
private struct DecimalProxy
{
public readonly int flags;
public readonly int hi;
public readonly int lo;
public readonly int mid;
}

68. var d = 42m;
var decimalProxy =
*((DecimalProxy*)(&d));
var flags = decimalProxy.flags;
var lo = decimalProxy.lo;
var mid = decimalProxy.mid;
var hi = decimalProxy.hi;
// Enjoy your flags-lo-mid-high!

72. ’

74. // using lambda
DoSomething(() => Console.WriteLine());
// delegate from method group
DoSomething(Console.WriteLine);
// capturing local variable
DoSomething(() => local++);
// capturing field
DoSomething(() => _field++);

75. public class NCrafts
{
private int _field;
private void DoSomething(Action action){}
public void Test()
{
DoSomething(() => _field++);
}
}

76. public class NCrafts
{
private int _field;
private void DoSomething(Action action){}
public void Test()
{
DoSomething(new Action(AnonymousMethod));
}
[CompilerGenerated]
public void AnonymousMethod()
{
_field++;
}
}

77. public class NCrafts
{
private static int _field;
private void DoSomething(Action action){}
public void Test()
{
DoSomething(() => _field++);
}
}

78. public class NCrafts
{
[CompilerGenerated]
private static Action _cachedDelegate;
private static int _field;
private static void DoSomething(Action action){}
public void Test()
{
if (_cachedDelegate == null)
_cachedDelegate = new Action(Anonymous);
DoSomething(_cachedDelegate);
}
[CompilerGenerated]
private static void Anonymous()
{
_field++;
}
}

85. }
finally
{

86. // low-latency
// can be a
// business
// requirement

87. // it’s hard no
// matter what
// stack you
// rely on

88. // low-latency
// in managed
// code is a
// real option

89. // is there a
// trend here?
talk.Close();
}