H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 14:46:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
3f5ebfbde3
source-engine/public/tier0/EventModes.h

1788 lines
31 KiB
C
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#ifndef EVENTMODES_H
#define EVENTMODES_H
#pragma once
/*
Event Modes to choose from:
P4Event_TC_deliver_mode
P4Event_BPU_fetch_request
P4Event_ITLB_reference
P4Event_memory_cancel
P4Event_memory_complete
P4Event_load_port_replay
P4Event_store_port_replay
P4Event_MOB_load_replay
P4Event_page_walk_type
P4Event_BSQ_cache_reference
P4Event_IOQ_allocation
P4Event_IOQ_active_entries
P4Event_FSB_data_activity
P4Event_BSQ_allocation
P4Event_BSQ_active_entries
P4Event_SSE_input_assist
P4Event_packed_SP_uop
P4Event_packed_DP_uop
P4Event_scalar_SP_uop
P4Event_scalar_DP_uop
P4Event_64bit_MMX_uop
P4Event_128bit_MMX_uop
P4Event_x87_FP_uop
P4Event_x87_SIMD_moves_uop
P4Event_TC_misc
P4Event_global_power_events
P4Event_tc_ms_xfer
P4Event_uop_queue_writes
P4Event_retired_mispred_branch_type
P4Event_retired_branch_type
P4Event_resource_stall
P4Event_WC_Buffer
P4Event_b2b_cycles
P4Event_bnr
P4Event_snoop
P4Event_response
P4Event_front_end_event
P4Event_execution_event
P4Event_replay_event
P4Event_instr_retired
P4Event_uops_retired
P4Event_uop_type
P4Event_branch_retired
P4Event_mispred_branch_retired
P4Event_x87_assist
P4Event_machine_clear
*/
class P4P4Event_TC_deliver_mode: public P4BaseEvent
{
public:
EVENT_MASK(TC_deliver_mode) * eventMask;
P4P4Event_TC_deliver_mode()
{
eventMask = (EVENT_MASK(TC_deliver_mode) *)&m_eventMask;
escr.ESCREventSelect = 0x01;
cccr.CCCRSelect = 0x01;
//// eventType = EVENT_TYPE(TC_deliver_mode);
description = _T("TC_deliver_mode");
UseCounter4();
}
void UseCounter4()
{
SetCounter(4);;
}
void UseCounter5()
{
SetCounter(5);
}
void UseCounter6()
{
SetCounter(6);
}
void UseCounter7()
{
SetCounter(7);
}
};
class P4P4Event_BPU_fetch_request: public P4BaseEvent
{
public:
EVENT_MASK(BPU_fetch_request)* eventMask;
P4P4Event_BPU_fetch_request()
{
eventMask = (EVENT_MASK(BPU_fetch_request) *)&m_eventMask;
escr.ESCREventSelect= 0x03;
cccr.CCCRSelect= 0x00;
// eventType = EVENT_TYPE(BPU_fetch_request);
description=_T("BPU_fetch_request");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4P4Event_ITLB_reference: public P4BaseEvent
{
public:
EVENT_MASK(ITLB_reference) * eventMask;
P4P4Event_ITLB_reference()
{
eventMask = (EVENT_MASK(ITLB_reference) *)&m_eventMask;
escr.ESCREventSelect= 0x18;
cccr.CCCRSelect= 0x03;
// eventType=EVENT_TYPE(ITLB_reference);
description=_T("ITLB_reference");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_memory_cancel: public P4BaseEvent
{
public:
EVENT_MASK(memory_cancel) * eventMask;
P4Event_memory_cancel()
{
eventMask = (EVENT_MASK(memory_cancel) *)&m_eventMask;
escr.ESCREventSelect= 0x02;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(memory_cancel);
description=_T("memory_cancel");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_memory_complete: public P4BaseEvent
{
public:
EVENT_MASK(memory_complete) * eventMask;
P4Event_memory_complete()
{
eventMask = (EVENT_MASK(memory_complete) *)&m_eventMask;
escr.ESCREventSelect= 0x08;
cccr.CCCRSelect= 0x02;
// eventType=EVENT_TYPE(memory_complete);
description=_T("memory_complete");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_load_port_replay: public P4BaseEvent
{
public:
EVENT_MASK(load_port_replay) * eventMask;
P4Event_load_port_replay()
{
eventMask = (EVENT_MASK(load_port_replay) *)&m_eventMask;
escr.ESCREventSelect= 0x04;
cccr.CCCRSelect= 0x02;
// eventType=EVENT_TYPE(load_port_replay);
description=_T("load_port_replay");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_store_port_replay: public P4BaseEvent
{
public:
EVENT_MASK(store_port_replay) * eventMask;
P4Event_store_port_replay()
{
eventMask = (EVENT_MASK(store_port_replay) *)&m_eventMask;
escr.ESCREventSelect= 0x05;
cccr.CCCRSelect= 0x02;
// eventType=EVENT_TYPE(store_port_replay);
description=_T("store_port_replay");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_MOB_load_replay: public P4BaseEvent
{
public:
EVENT_MASK(MOB_load_replay) * eventMask;
P4Event_MOB_load_replay()
{
eventMask = (EVENT_MASK(MOB_load_replay) *)&m_eventMask;
escr.ESCREventSelect= 0x03;
cccr.CCCRSelect= 0x02;
// eventType=EVENT_TYPE(MOB_load_replay);
description=_T("MOB_load_replay");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_page_walk_type: public P4BaseEvent
{
public:
EVENT_MASK(page_walk_type) * eventMask;
P4Event_page_walk_type()
{
eventMask = (EVENT_MASK(page_walk_type) *)&m_eventMask;
escr.ESCREventSelect= 0x01;
cccr.CCCRSelect= 0x04;
// eventType=EVENT_TYPE(page_walk_type);
description=_T("page_walk_type");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_BSQ_cache_reference: public P4BaseEvent
{
public:
EVENT_MASK(BSQ_cache_reference) * eventMask;
P4Event_BSQ_cache_reference()
{
eventMask = (EVENT_MASK(BSQ_cache_reference) *)&m_eventMask;
escr.ESCREventSelect= 0x0C;
cccr.CCCRSelect= 0x07;
// eventType=EVENT_TYPE(BSQ_cache_reference);
description=_T("BSQ_cache_reference");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_IOQ_allocation: public P4BaseEvent
{
public:
EVENT_MASK(IOQ) * eventMask;
P4Event_IOQ_allocation()
{
eventMask = (EVENT_MASK(IOQ) *)&m_eventMask;
escr.ESCREventSelect= 0x03;
cccr.CCCRSelect= 0x06;
// eventType=EVENT_TYPE(IOQ);
description=_T("IOQ_allocation");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_IOQ_active_entries: public P4BaseEvent
{
public:
EVENT_MASK(IOQ) * eventMask;
P4Event_IOQ_active_entries()
{
eventMask = (EVENT_MASK(IOQ) *)&m_eventMask;
escr.ESCREventSelect= 0x1A;
cccr.CCCRSelect= 0x06;
// eventType=EVENT_TYPE(IOQ);
description=_T("IOQ_active_entries");
UseCounter2();
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_FSB_data_activity: public P4BaseEvent
{
public:
EVENT_MASK(FSB_data_activity) * eventMask;
P4Event_FSB_data_activity()
{
eventMask = (EVENT_MASK(FSB_data_activity) *)&m_eventMask;
escr.ESCREventSelect= 0x17;
cccr.CCCRSelect= 0x06;
// eventType=EVENT_TYPE(FSB_data_activity);
description=_T("FSB_data_activity");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_BSQ_allocation: public P4BaseEvent
{
public:
EVENT_MASK(BSQ) * eventMask;
P4Event_BSQ_allocation()
{
eventMask = (EVENT_MASK(BSQ) *)&m_eventMask;
escr.ESCREventSelect= 0x05;
cccr.CCCRSelect= 0x07;
// eventType=EVENT_TYPE(BSQ);
description=_T("BSQ_allocation");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
};
class P4Event_BSQ_active_entries: public P4BaseEvent
{
public:
EVENT_MASK(BSQ) * eventMask;
P4Event_BSQ_active_entries()
{
eventMask = (EVENT_MASK(BSQ) *)&m_eventMask;
escr.ESCREventSelect= 0x06;
cccr.CCCRSelect= 0x07;
// eventType=EVENT_TYPE(BSQ);
description=_T("bsq_active_entries");
UseCounter2();
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_SSE_input_assist: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_SSE_input_assist()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x34;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("SSE_input_assist");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_packed_SP_uop: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_packed_SP_uop()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x08;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("packed_SP_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_packed_DP_uop: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_packed_DP_uop()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x0C;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("packed_DP_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_scalar_SP_uop: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_scalar_SP_uop()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x0A;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("scalar_SP_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_scalar_DP_uop: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_scalar_DP_uop()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x0E;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("scalar_DP_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_64bit_MMX_uop: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_64bit_MMX_uop()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x02;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("64bit_MMX_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_128bit_MMX_uop: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_128bit_MMX_uop()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x1A;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("128bit_MMX_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_x87_FP_uop: public P4BaseEvent
{
public:
EVENT_MASK(firm_uop) * eventMask;
P4Event_x87_FP_uop()
{
eventMask = (EVENT_MASK(firm_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x04;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(firm_uop);
description=_T("x87_FP_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_x87_SIMD_moves_uop: public P4BaseEvent
{
public:
EVENT_MASK(x87_SIMD_moves_uop) * eventMask;
P4Event_x87_SIMD_moves_uop()
{
eventMask = (EVENT_MASK(x87_SIMD_moves_uop) *)&m_eventMask;
escr.ESCREventSelect= 0x2E;
cccr.CCCRSelect= 0;
// eventType=EVENT_TYPE(x87_SIMD_moves_uop);
description=_T("x87_SIMD_moves_uop");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_TC_misc: public P4BaseEvent
{
public:
EVENT_MASK(TC_misc) * eventMask;
P4Event_TC_misc()
{
eventMask = (EVENT_MASK(TC_misc) *)&m_eventMask;
escr.ESCREventSelect= 0x06;
cccr.CCCRSelect= 0x01;
// eventType=EVENT_TYPE(TC_misc);
description=_T("TC_misc");
UseCounter4();
}
void UseCounter4()
{
SetCounter(4);;
}
void UseCounter5()
{
SetCounter(5);
}
void UseCounter6()
{
SetCounter(6);
}
void UseCounter7()
{
SetCounter(7);
}
};
class P4Event_global_power_events: public P4BaseEvent
{
public:
EVENT_MASK(global_power_events) * eventMask;
P4Event_global_power_events()
{
eventMask = (EVENT_MASK(global_power_events) *)&m_eventMask;
escr.ESCREventSelect= 0x13;
cccr.CCCRSelect= 0x06;
// eventType=EVENT_TYPE(global_power_events);
description=_T("global_power_events");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_tc_ms_xfer: public P4BaseEvent
{
public:
EVENT_MASK(tc_ms_xfer) * eventMask;
P4Event_tc_ms_xfer()
{
eventMask = (EVENT_MASK(tc_ms_xfer) *)&m_eventMask;
escr.ESCREventSelect= 0x05;
cccr.CCCRSelect= 0x00;
// eventType=EVENT_TYPE(tc_ms_xfer);
description=_T("tc_ms_xfer");
UseCounter4();
}
void UseCounter4()
{
SetCounter(4);;
}
void UseCounter5()
{
SetCounter(5);
}
void UseCounter6()
{
SetCounter(6);
}
void UseCounter7()
{
SetCounter(7);
}
};
class P4Event_uop_queue_writes: public P4BaseEvent
{
public:
EVENT_MASK(uop_queue_writes) * eventMask;
P4Event_uop_queue_writes()
{
eventMask = (EVENT_MASK(uop_queue_writes) *)&m_eventMask;
escr.ESCREventSelect= 0x09;
cccr.CCCRSelect= 0x00;
// eventType=EVENT_TYPE(uop_queue_writes);
description=_T("uop_queue_writes");
UseCounter4();
}
void UseCounter4()
{
SetCounter(4);;
}
void UseCounter5()
{
SetCounter(5);
}
void UseCounter6()
{
SetCounter(6);
}
void UseCounter7()
{
SetCounter(7);
}
};
class P4Event_retired_mispred_branch_type: public P4BaseEvent
{
public:
EVENT_MASK(branch_type) * eventMask;
P4Event_retired_mispred_branch_type()
{
eventMask = (EVENT_MASK(branch_type) *)&m_eventMask;
escr.ESCREventSelect= 0x05;
cccr.CCCRSelect= 0x02;
// eventType=EVENT_TYPE(branch_type);
description=_T("retired_mispred_branch_type");
UseCounter4();
}
void UseCounter4()
{
SetCounter(4);;
}
void UseCounter5()
{
SetCounter(5);
}
void UseCounter6()
{
SetCounter(6);
}
void UseCounter7()
{
SetCounter(7);
}
};
class P4Event_retired_branch_type: public P4BaseEvent
{
public:
EVENT_MASK(branch_type) * eventMask;
P4Event_retired_branch_type()
{
eventMask = (EVENT_MASK(branch_type) *)&m_eventMask;
escr.ESCREventSelect= 0x04;
cccr.CCCRSelect= 0x04;
// eventType=EVENT_TYPE(branch_type);
description=_T("retired_branch_type");
UseCounter4();
}
void UseCounter4()
{
SetCounter(4);;
}
void UseCounter5()
{
SetCounter(5);
}
void UseCounter6()
{
SetCounter(6);
}
void UseCounter7()
{
SetCounter(7);
}
};
class P4Event_resource_stall: public P4BaseEvent
{
public:
EVENT_MASK(resource_stall) * eventMask;
P4Event_resource_stall()
{
eventMask = (EVENT_MASK(resource_stall) *)&m_eventMask;
escr.ESCREventSelect= 0x01;
cccr.CCCRSelect= 0x02;
// eventType=EVENT_TYPE(resource_stall);
description=_T("resource_stall");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_WC_Buffer: public P4BaseEvent
{
public:
EVENT_MASK(WC_Buffer) * eventMask;
P4Event_WC_Buffer()
{
eventMask = (EVENT_MASK(WC_Buffer) *)&m_eventMask;
escr.ESCREventSelect= 0x05;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(WC_Buffer);
description=_T("WC_Buffer");
UseCounter8();
}
void UseCounter8()
{
SetCounter(8);
}
void UseCounter9()
{
SetCounter(9);
}
void UseCounter10()
{
SetCounter(10);
}
void UseCounter11()
{
SetCounter(11);
}
};
class P4Event_b2b_cycles: public P4BaseEvent
{
public:
EVENT_MASK(b2b_cycles) * eventMask;
P4Event_b2b_cycles()
{
eventMask = (EVENT_MASK(b2b_cycles) *)&m_eventMask;
escr.ESCREventSelect= 0x16;
cccr.CCCRSelect= 0x03;
// eventType=EVENT_TYPE(b2b_cycles);
description=_T("b2b_cycles");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_bnr: public P4BaseEvent
{
public:
EVENT_MASK(bnr) * eventMask;
P4Event_bnr()
{
eventMask = (EVENT_MASK(bnr) *)&m_eventMask;
escr.ESCREventSelect= 0x08;
cccr.CCCRSelect= 0x03;
// eventType=EVENT_TYPE(bnr);
description=_T("bnr");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_snoop: public P4BaseEvent
{
public:
EVENT_MASK(snoop) * eventMask;
P4Event_snoop()
{
eventMask = (EVENT_MASK(snoop) *)&m_eventMask;
escr.ESCREventSelect= 0x06;
cccr.CCCRSelect= 0x03;
// eventType=EVENT_TYPE(snoop);
description=_T("snoop");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_response: public P4BaseEvent
{
public:
EVENT_MASK(response) * eventMask;
P4Event_response()
{
eventMask = (EVENT_MASK(response) *)&m_eventMask;
escr.ESCREventSelect= 0x04;
cccr.CCCRSelect= 0x03;
// eventType=EVENT_TYPE(response);
description=_T("response");
UseCounter0();
}
void UseCounter0()
{
SetCounter(0);
}
void UseCounter1()
{
SetCounter(1);
}
void UseCounter2()
{
SetCounter(2);
}
void UseCounter3()
{
SetCounter(3);
}
};
class P4Event_front_end_event: public P4BaseEvent
{
public:
EVENT_MASK(nbogus_bogus) * eventMask;
P4Event_front_end_event()
{
eventMask = (EVENT_MASK(nbogus_bogus) *)&m_eventMask;
escr.ESCREventSelect= 0x08;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(nbogus_bogus);
description=_T("front_end_event");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_execution_event: public P4BaseEvent
{
public:
EVENT_MASK(execution_event) * eventMask;
P4Event_execution_event()
{
eventMask = (EVENT_MASK(execution_event) *)&m_eventMask;
escr.ESCREventSelect= 0x0C;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(execution_event);
description=_T("execution_event");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_replay_event: public P4BaseEvent
{
public:
EVENT_MASK(nbogus_bogus) * eventMask;
P4Event_replay_event()
{
eventMask = (EVENT_MASK(nbogus_bogus) *)&m_eventMask;
escr.ESCREventSelect= 0x09;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(nbogus_bogus);
description=_T("replay_event");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_instr_retired: public P4BaseEvent
{
public:
EVENT_MASK(instr_retired) * eventMask;
P4Event_instr_retired()
{
eventMask = (EVENT_MASK(instr_retired) *)&m_eventMask;
escr.ESCREventSelect= 0x02;
cccr.CCCRSelect= 0x04;
// eventType=EVENT_TYPE(instr_retired);
description=_T("instr_retired");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_uops_retired: public P4BaseEvent
{
public:
EVENT_MASK(nbogus_bogus) * eventMask;
P4Event_uops_retired()
{
eventMask = (EVENT_MASK(nbogus_bogus) *)&m_eventMask;
escr.ESCREventSelect= 0x01;
cccr.CCCRSelect= 0x04;
// eventType=EVENT_TYPE(nbogus_bogus);
description=_T("uops_retired");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_uop_type: public P4BaseEvent
{
public:
EVENT_MASK(uop_type) * eventMask;
P4Event_uop_type()
{
eventMask = (EVENT_MASK(uop_type) *)&m_eventMask;
escr.ESCREventSelect= 0x02;
cccr.CCCRSelect= 0x02;
// eventType=EVENT_TYPE(uop_type);
description=_T("uop_type");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_branch_retired: public P4BaseEvent
{
public:
EVENT_MASK(branch_retired) * eventMask;
P4Event_branch_retired()
{
eventMask = (EVENT_MASK(branch_retired) *)&m_eventMask;
escr.ESCREventSelect= 0x06;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(branch_retired);
description=_T("branch_retired");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_mispred_branch_retired: public P4BaseEvent
{
public:
EVENT_MASK(mispred_branch_retired) * eventMask;
P4Event_mispred_branch_retired()
{
eventMask = (EVENT_MASK(mispred_branch_retired) *)&m_eventMask;
escr.ESCREventSelect= 0x03;
cccr.CCCRSelect= 0x04;
// eventType=EVENT_TYPE(mispred_branch_retired);
description=_T("mispred_branch_retired");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_x87_assist: public P4BaseEvent
{
public:
EVENT_MASK(x87_assist) * eventMask;
P4Event_x87_assist()
{
eventMask = (EVENT_MASK(x87_assist) *)&m_eventMask;
escr.ESCREventSelect= 0x03;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(x87_assist);
description=_T("x87_assist");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
class P4Event_machine_clear: public P4BaseEvent
{
public:
EVENT_MASK(machine_clear) * eventMask;
P4Event_machine_clear()
{
eventMask = (EVENT_MASK(machine_clear) *)&m_eventMask;
escr.ESCREventSelect= 0x02;
cccr.CCCRSelect= 0x05;
// eventType=EVENT_TYPE(machine_clear);
description=_T("machine_clear");
UseCounter12();
}
void UseCounter12()
{
SetCounter(12);
}
void UseCounter13()
{
SetCounter(13);
}
void UseCounter14()
{
SetCounter(14);
}
void UseCounter15()
{
SetCounter(15);
}
void UseCounter16()
{
SetCounter(16);
}
void UseCounter17()
{
SetCounter(17);
}
};
#endif // EVENTMODES_H
Reference in New Issue Copy Permalink