Tracing V2 prototype [NOT FOR REVIEW]

Tracing V2 prototype [NOT FOR REVIEW]

VIEWER DISCRETION IS ADVISED
This is a highly dirty prototype of tracing v2.

It serves as a proof of concept, showing how to rebase
existing trace macros on zero-copy zero-malloc protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible,
didn't spend too much time.

perf TL;DR
 - simple trace events are marginally slower on arm (in the 10% ballpark)
 and slighly faster on x86.
 - complex trace events are ~2x faster in Tracing V2 \o/

Also the proto generator (tracing_protoc.py) is all hacked up.
kraynov is working on a proper one in C++ based on protoc
plugin infrastructure.

All times are us. from ThreadTicks.

On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=

[Primiano Tucci (use gerrit), 2016-05-25 17:20:36]

Description was changed from

==========
WIP Tracing V2

BUG=
==========

to

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible, 
I didn't have time yet.


BUG=
==========

[Primiano Tucci (use gerrit), 2016-05-25 19:16:11]

Description was changed from

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible, 
I didn't have time yet.


BUG=
==========

to

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible, didn't spend too much
time.

On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=
==========

[Primiano Tucci (use gerrit), 2016-05-25 19:18:30]

Description was changed from

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible, didn't spend too much
time.

On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=
==========

to

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible,
didn't spend too much time.

perf TL;DR
 - simple trace events are marginally slower on arm (in the 10% ballpark)
 and slighly faster on x86.
 - complex trace events are ~2x faster in Tracing V2 \o/

Also the proto generator (tracing_protoc.py) is all hacked up.
kraynov is working on a proper one in C++ based on protoc
plugin infrastructure.


On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=
==========

[Primiano Tucci (use gerrit), 2016-05-25 19:19:22]

Description was changed from

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible,
didn't spend too much time.

perf TL;DR
 - simple trace events are marginally slower on arm (in the 10% ballpark)
 and slighly faster on x86.
 - complex trace events are ~2x faster in Tracing V2 \o/

Also the proto generator (tracing_protoc.py) is all hacked up.
kraynov is working on a proper one in C++ based on protoc
plugin infrastructure.


On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=
==========

to

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible,
didn't spend too much time.

perf TL;DR
 - simple trace events are marginally slower on arm (in the 10% ballpark)
 and slighly faster on x86.
 - complex trace events are ~2x faster in Tracing V2 \o/

Also the proto generator (tracing_protoc.py) is all hacked up.
kraynov is working on a proper one in C++ based on protoc
plugin infrastructure.

All times are us. from ThreadTicks.

On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=
==========

[Primiano Tucci (use gerrit), 2016-05-27 10:33:53]

Description was changed from

==========
Tracing V2 prototype [NOT FOR REVIEW]

This is highly dirty prototype of tracing v2.
It serves as a proof of concept, showing how to base
existing trace macros on protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible,
didn't spend too much time.

perf TL;DR
 - simple trace events are marginally slower on arm (in the 10% ballpark)
 and slighly faster on x86.
 - complex trace events are ~2x faster in Tracing V2 \o/

Also the proto generator (tracing_protoc.py) is all hacked up.
kraynov is working on a proper one in C++ based on protoc
plugin infrastructure.

All times are us. from ThreadTicks.

On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=
==========

to

==========
Tracing V2 prototype [NOT FOR REVIEW]

VIEWER DISCRETION IS ADVISED
This is a highly dirty prototype of tracing v2.

It serves as a proof of concept, showing how to rebase
existing trace macros on zero-copy zero-malloc protobuf.
Also it serves as a baseline to get some perf numbers.
There are quite some micro-optimizations still possible,
didn't spend too much time.

perf TL;DR
 - simple trace events are marginally slower on arm (in the 10% ballpark)
 and slighly faster on x86.
 - complex trace events are ~2x faster in Tracing V2 \o/

Also the proto generator (tracing_protoc.py) is all hacked up.
kraynov is working on a proper one in C++ based on protoc
plugin infrastructure.

All times are us. from ThreadTicks.

On X86_64
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg:   95, med:  106 
Using Tracing V=2, N-args=0    times (for 100 runs): avg:   93, med:   88 

Using Tracing V=1, N-args=1    times (for 100 runs): avg:   92, med:  105 
Using Tracing V=2, N-args=1    times (for 100 runs): avg:   97, med:   93 

Using Tracing V=1, N-args=2    times (for 100 runs): avg:   93, med:   85 
Using Tracing V=2, N-args=2    times (for 100 runs): avg:  102, med:  102 

Using Tracing V=1, N-args=42    times (for 100 runs): avg:  196, med:  205 
Using Tracing V=2, N-args=42    times (for 100 runs): avg:  125, med:  118 
------------------------------------------------------------------------------

On arm
------------------------------------------------------------------------------
Using Tracing V=1, N-args=0    times (for 100 runs): avg: 2247, med: 2442 
Using Tracing V=2, N-args=0    times (for 100 runs): avg: 2445, med: 2472 

Using Tracing V=1, N-args=1    times (for 100 runs): avg: 2397, med: 2411 
Using Tracing V=2, N-args=1    times (for 100 runs): avg: 2718, med: 2717 

Using Tracing V=1, N-args=2    times (for 100 runs): avg: 2388, med: 2442 
Using Tracing V=2, N-args=2    times (for 100 runs): avg: 2805, med: 2838 

Using Tracing V=1, N-args=42    times (for 100 runs): avg: 6761, med: 6897 
Using Tracing V=2, N-args=42    times (for 100 runs): avg: 3464, med: 3388 
------------------------------------------------------------------------------

BUG=
==========