Measurement.h

Go to the documentation of this file.

/* Copyright (C) 2002 Carsten Griwodz
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, this code may be used in unmodified form
 * provided that this copyright notice and this permission notice appear
 * in supporting documentation.
 *
 * The code may be made subject to the terms of the GNU General Public
 * License, Version 2, and re-distributed under the terms of this license.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after negotiation of conditions with the authors.
 */
#include <config.h>

namespace SH
{

#define MEASUREMENT_MODE 0 // dont measure anything
// #define MEASUREMENT_MODE 1  // measure configurations for nop-active-nop
// #define MEASUREMENT_MODE 2  // measure configurations for dummy later & RTP
// #define MEASUREMENT_MODE 3  // measure data passing for nop-active-nop

#define MEASURE_1(point)
#define MEASUREB_1(point,sub)
#define MEASUREFLUSH
#define MEASURE_2(point)
#define MEASUREB_2(point,sub)
#define MEASURE_3(point)
#define MEASUREGET_3(dest)
#define MEASURESTORE_3(dest,point)
#if MEASUREMENT_MODE == 0
#  undef HAVE_PENTIUM_PROBE
#elif MEASUREMENT_MODE == 1
#  undef MEASURE_1
#  undef MEASUREB_1
#  undef MEASUREFLUSH
#  define MEASURE_1(point) Measurement::measure( point );
#  define MEASUREB_1(point,sub) Measurement::measure( point,sub );
#  define MEASUREFLUSH Measurement::flushpipe( );
#elif MEASUREMENT_MODE == 2
#  undef MEASURE_2
#  undef MEASUREB_2
#  define MEASURE_2(point) Measurement::measure( point );
#  define MEASUREB_2(point,sub) Measurement::measure( point,sub );
#elif MEASUREMENT_MODE == 3
#  undef MEASURE_3
#  undef MEASUREGET_3
#  undef MEASURESTORE_3
#  define MEASURE_3(point) Measurement::measure( point );
#  define MEASUREGET_3(dest) Measurement::measure_get( dest );
#  define MEASURESTORE_3(dest,point) Measurement::measure_store( dest, point );
#endif

class Measurement
{
public:
    enum Index
    {
        Begin,

#if MEASUREMENT_MODE == 2
        BeforeCode,
        EnterCode,
        LeaveCode,
        AfterCode,
#endif

#if (MEASUREMENT_MODE == 1) | (MEASUREMENT_MODE == 2)
        BeforePull,
        EnterPull,
        LeavePull,
        AfterPull,

        BeforePush,
        EnterPush,
        LeavePush,
        AfterPush,
#endif

        End,
        NumMeasurements
    };

#ifdef HAVE_PENTIUM_PROBE
    inline static void flushpipe( )
    {
        __asm __volatile( "push %eax\n"
                          "push %ebx\n"
                          "push %ecx\n"
                          "push %edx\n"
                          "cpuid\n"
                          "pop %edx\n"
                          "pop %ecx\n"
                          "pop %ebx\n"
                          "pop %eax\n" );
    }

    inline static void measure( Measurement::Index i, int subcodepoint=0 )
    {
        if( _first ) init( );
        // CPUID
        // __asm __volatile(".byte 0x0f,0xa2");

        // RDTSC
        __asm __volatile(".byte 0x0f,0x31" : "=A" (cur->entry[i]));

        Measurement::_codepoint[i][subcodepoint] += 1;

        if( i == End )
        {
            cur++;
            if( cur == _last )
            {
                dump();
            }
        }
    }

    inline static void measure_get( u_int64_t& dest )
    {
        __asm __volatile(".byte 0x0f,0x31" : "=A" (dest));
    }

    inline static void measure_store( u_int64_t dest, Measurement::Index i, int subcodepoint=0 )
    {
        if( _first ) init( );
        cur->entry[i] = dest;
        Measurement::_codepoint[i][subcodepoint] += 1;

        if( i == End )
        {
            cur++;
            if( cur == _last )
            {
                dump();
            }
        }
    }

private:
    u_int64_t entry[NumMeasurements];

    static const size_t _max_cycles = 2000000;
    static bool         _first;
    static Measurement* _array;
    static Measurement* cur;
    static Measurement* _last;
    static size_t       _codepoint[NumMeasurements][3];

    static void init( );
    static void dump( );

#else
    inline static void measure( Measurement::Index, int=0 ) { }
#endif /* HAVE_PENTIUM_PROBE */

    friend class Stat;
};

}; // namespace SH

---