Creating a Trace Object

View the trace

What is a Trigger?

A trigger is the combination of the following:

* A TRAPpy event
* A pivot for the event
* A set of filters
* A value

Introduction to Triggers

• The example below explains how to create a trigger for the event when a particular process is switched in or out.

• This uses the trappy.sched.SchedSwitch event in the trace object. This event looks for the unique_word sched_switch in the trace file.

• Here is sample line in the text trace that corresponds to the SchedSwitch event.

sched_switch: prev_comm=trace-cmd prev_pid=4731 prev_prio=120 prev_state=1 next_comm=trace-cmd next_pid=4730 next_prio=120

We can see that this event is populated in the above trace object as:

Now, let us suppose we want to create a trigger for the event when the task trace-cmd (pid=4729) is switched in and assign a value of 1 to the Trigger signal. In pseudo code:

if next_pid == 4729:
    Trigger_In(t) = 1

We can similarly create a Trigger for the event when the task is switched out:

if prev_pid == 4729:
    Trigger_Out(t) = -1

A pivot is the column along which the data is orthogonal. If the data is pivotable it is possibly a super-position of smaller data elements corresponding to each unique pivot value. In our case the pivot value is "__cpu" and the data can be split into the scheduler switches happening on the different CPUs

Topology and Aggregation

Creating a CPU (pivot) Topology

A topology can be explained as a collection of different arrangements of groups of nodes. These different arrangements are called levels. Each level has a multiple groups of nodes. For example for a CPU topology can have the following levels:

• CPU

    [
        [cpu0],
        [cpu1],
        .
        .
        [cpuN],
    ]

• Cluster

    [
        [custer1_cpu1, cluster1_cpu2, ... cluster1_cpuM)],
        .
        .
        .
        [custerK_cpu1, clusterK_cpu2, ... clusterK_cpuP)]
    ]

• System

    [
        [cpu0,
         cpu1,
         .
         .
         .
         cpuN]
    ]

• Aggregator facilitates the aggregation of signals from different triggers. The aggregator also understands a topology over which the aggregation can be performed and this aggregation can be expressed as a function which takes pandas.Series as an input. For example.

    def aggfunc(series):
           return modify(series)

• The elements in the topology should be a superset of the pivot values of the Triggers. In our case the pivot value is "__cpu", so, the Topology corresponds to a CPU topology.

Base Aggregation

• Topology.flatten() gives the list of all the nodes in the Topology.
• The node in the Topology corresponds to a pivot value in the Trigger
• The signals for the pivot value are super imposed and stored in a dictionary.

Here is an informal pseudo-code for this base aggregation:

base_signals = {}

for node in topology.flatten():
    node_signal = init_signal()

    for trigger in triggers:
        node_signal.union(trigger.get_signal_for_pivot_val(node))

    base_signal[node] = node_signal

Aggregation over the topology

The Aggregator.aggregate accepts a level parameter:

• Each level in the topology contains a group of nodes

• These can be accessed as

      topology.get_level(level)

Here is an informal psuedo-code for this aggregation over the Topology:

agg_signal = []

for group_of_nodes in Topology.get_level(level):

    for node in group_of_nodes:

        group_signal = init_signal()
        group_signal += aggfunc(base_signals[node])

    agg_signal.append(group_signal)

Create the Aggregator

Examples of Aggregation

Aggregate at Cluster level

Aggregate at CPU level

Aggregator Function can return Scalars

An aggregator function can return a scalar, for example the number of "switch ins". Each value in the result has a one-to-one correspondence with the groups in Topology.get_level(level)