This document describes overhead produced by the MyARM ARM implementation and the methods how the overhead was measured.

Performance impact

Measuring any business or technical transactions needs to execute itself. Therefore getting measurement information is not just for free. In order to decide if the instrumentation does not significantly interfere with the real application tasks the performance impact of the instrumentation is good to know. As of its nature it is highly hardware and platform dependent with higher performing processors the performance impact of the measurement decreases expressed in real time.

One key question about instrumentation for measuring performance is the performance overhead of the measurement itself. The interference with the application to measure should be reduced to a minimum. The MyARM ARM implementation is written with this requirement in mind.

Overhead measurement

ARM can be used in a variety of use cases therefore we measured the overhead of MyARM as described in the following section.

Simulating a real application

Simulation of a real application is done using busy waiting for a defined number of microseconds (application load, t_app). Each such task is measured using normal ARM start and stop calls (instrumentation overhead,t_arm ). The simulation application runs a defined number of seconds. Therefore the total number of ARM transaction measurements N_arm and the total time of the application T_app (application load) can be easily calculated using the following formulas:

• T_app = 60 seconds
• t_app = 1 millisecond
• N_arm = T_app/t_app*1000

When the ARM instrumentation ideally needs no time the application would execute exactly in 60 seconds. This is for sure not true, therefore we measure the overall execution time (R_app) of the running application without initialization and termination of the application. The difference between the measured execution time and the 60 seconds are the overhead for the ARM instrumentation. This can be broken down to a single transaction measurement overhead by the following formula:

• t_arm = (R_app-T_app)/N_arm

ARM optional features

One major factor influencing the performance impact is how many and which context information is associated with a transaction measurement. The different optional features (correlators, metrics and context values) of ARM influences the time spent by the ARM instrumentation in manifold ways. To reflect these options we measured the overhead of MyARM for the following typical ARM instrumentation patterns:

1. Simple transaction measurement using null call library (e.g. libarm4null.so for the ARM 4.0 C binding) (NullCall).
2. Simple transaction measurement without any additional data (Simple).
3. Simple transaction measurement returning a correlator (CorrGen).
4. Transaction measurement with 3 gauge metrics attached (Metrics).
5. Transaction measurement with 1 context value string of size 100 Bytes (Ctxt 1).
6. Transaction measurement with 5 context value string of size 100 Bytes (Ctxt 5).
7. Transaction measurement with 10 context value string of size 100 Bytes (Ctxt 10).
8. Transaction measurement with 20 context value string of size 100 Bytes (Ctxt 20).

Test environment

All tests were executed on an Intel^®Core^TMi7-3517UE CPU (CompuLab Intense PC) running under Linux (Ubuntu-based) in 64bit using kernel 3.13.0-24-generic.

Agent bindings

The following figure shows the transaction measurement overhead for the simulated application and the ARM optional features as described in section ARM optional features for the ARM 4.0 C-, Java- and C#-Agent.

ARM 4.0 C Binding

Overhead

This section describes the transaction measurement overhead of the ARM 4.0 C binding using the arm_start_transaction() and arm_stop_transaction() function calls.

The shown results are the average transaction measurement overhead values from the last 10 MyARM builds of the version MyARM 4.0.x.0. See the following table for all detailed results:

Details

ARM 4.0 Java Binding

Overhead

This section describes the transaction measurement overhead of the ARM 4.0 Java binding using the ArmTransaction.start() and ArmTransaction.stop() method calls.

The shown results are the average transaction measurement overhead values from the last 10 MyARM builds of the version MyARM 4.0.x.0. See the following table for all detailed results:

Details

ARM 4.0 C# Binding

Overhead

This section describes the transaction measurement overhead of the ARM 4.0 C# binding using the IArmTransaction.start() and IArmTransaction.stop() method calls.

The shown results are the average transaction measurement overhead values from the last 10 MyARM builds of the version MyARM 4.0.x.0. See the following table for all detailed results:

Details