umc_log.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "umc_log.h"
#include "vm_debug.h"

using namespace UMC;

UMC::TraceLogToFile m_TraceToFile(WITHALL,NULL,__VM_STRING("   Date   ,  Time  ,Mem,File name, Class, Method, Description, Parameters"));

Counter::Counter(RESULT_TYPE _t) {
    reset();
    m_freq = vm_time_get_frequency();
    set_type(_t);
}

Counter::~Counter()
{
}

Counter::Counter(const char* name, RESULT_TYPE _t) {
    reset();
    m_name = name;
    m_freq = vm_time_get_frequency();
    set_type(_t);
}

void Counter::reset() {
    m_count      = 0;
    m_tick       = 0;
    m_total_tick = 0;
}

void Counter::start() {
    m_tick = vm_time_get_tick();
}

void Counter::stop() {
    m_total_tick += vm_time_get_tick() - m_tick;
    m_count++;
}

double Counter::get_value_fps() {
    return (double)(vm_var64s)(m_count*m_freq)/(double)(vm_var64s)(m_total_tick);
}

double Counter::get_value_mspf() {
    return ((double)(vm_var64s)(m_total_tick)/(double)(vm_var64s)(m_count*m_freq))*1000.;
}

double Counter::get_value() {
    return (this->*(m_func))();
}

void Counter::set_name(const char* name) {
    m_name = name;
}

const char* Counter::get_name() {
    return m_name;
}

void Counter::set_type(Counter::RESULT_TYPE _t) {
    switch(_t) {
        case FPS:
            m_func = (RESULT_FUNC)&Counter::get_value_fps;
            m_type = FPS;
            break;
        case MSPF:
            m_func = (RESULT_FUNC)&Counter::get_value_mspf;
            m_type = MSPF;
            break;
        default:
            m_func = NULL;
    }


}

Counter::RESULT_TYPE Counter::get_type()
{   return m_type;  }

CounterArray::CounterArray()
{
    m_array.DeleteAll();
    m_name = NULL;
}

CounterArray::~CounterArray() {
    unsigned int i, n;
    Counter*    counter;

    n = m_array.GetSize();

    for(i = 0; i < n; i++) {
        counter = m_array[i];
        if (counter) {
            delete counter;
            counter = NULL;
        }
    }

    m_array.DeleteAll();
}

Counter* CounterArray::add_counter(const char* name, Counter::RESULT_TYPE _t) {
    Counter* counter;
    int      i = m_array.GetSize();

    counter = new Counter(name, _t);

    if (counter) {
        m_array.Insert(i, counter);
    }

    return counter;
}

void CounterArray::dump_values() {

    unsigned int i, n;
    Counter*    counter;

    if (m_name)
      vm_debug_trace(-1,__VM_STRING("\n%s:\n"),m_name);

    n = m_array.GetSize();

    for(i = 0; i < n; i++) {
        counter = m_array[i];
        if (counter) {
            vm_debug_trace(-1,__VM_STRING("%s: %f"),counter->get_name(),counter->get_value());
            switch(counter->get_type()) {
                case Counter::MSPF:
                    vm_debug_trace(-1,__VM_STRING("(mspf)\n"));
                    break;
                case Counter::FPS:
                    vm_debug_trace(-1,__VM_STRING("(fps)\n"));
                    break;
                default:
                    vm_debug_trace(-1,__VM_STRING("(unknown unit)\n"));
                    break;
            }
        }
    }
}

const char* CounterArray::get_name() {
    return m_name;
}

void CounterArray::set_name(const char* name) {
    m_name = name;
}

#ifdef MEASURE_PERF
CounterArray         g_CounterArray;
Counter*             g_counter_virtual_call;
Counter*             g_counter_get_frame;
#endif