#include <ExecutionTrace.hh>

Collaboration diagram for ExecutionTrace:

Public Types
enum	ProcedureEntryType { PT_ENTRY = 0, PT_EXIT = 1 }
	a type for storing procedure entry type (entry/exit) More...

typedef std::string	AddressSpaceID
	a type for storing address space identifiers More...

typedef std::string	BusID
	a type for storing bus identifiers More...

typedef std::string	SocketID
	a type for storing socket identifiers More...

typedef std::string	SegmentID
	a type for storing bus segment identifiers More...

typedef std::string	FunctionUnitID
	a type for storing function unit identifiers More...

typedef std::string	OperationID
	a type for storing operation identifiers More...

typedef std::string	RegisterFileID
	a type for storing register file identifiers More...

typedef int	RegisterID
	a type for storing register ids More...

typedef unsigned int	MemoryAddress
	a type for storing memory addresses More...

typedef SimValue	MAU
	a type for storing data of size of the minimum addressable unit More...

typedef std::size_t	RegisterAccessCount
	a type for register access counts More...

typedef ClockCycleCount	OperationTriggerCount
	a type for operation trigger counts More...

typedef boost::tuple< RegisterAccessCount, RegisterAccessCount, ClockCycleCount >	ConcurrentRFAccessCount
	type to be used as a key for storing concurrent RF access info More...

typedef std::list< ConcurrentRFAccessCount >	ConcurrentRFAccessCountList
	type to be used for a list of concurrent RF accesses More...

typedef boost::tuple< OperationID, OperationTriggerCount >	FUOperationTriggerCount
	type to be used as a key for storing function unit operation execution counts More...

typedef std::list< FUOperationTriggerCount >	FUOperationTriggerCountList
	type to be used for lists of function operation execution counts More...

Public Member Functions
void	addInstructionExecution (ClockCycleCount cycle, InstructionAddress address)

void	addInstructionExecutionCount (InstructionAddress address, ClockCycleCount count)

void	addProcedureAddressRange (InstructionAddress firstAddress, InstructionAddress lastAddress, const std::string &procedureName)

void	addLockedCycle (ClockCycleCount cycle)

void	addBasicBlockStart (ClockCycleCount cycle, InstructionAddress address)

void	addMemoryAccess (ClockCycleCount cycle, const AddressSpaceID &addressSpace, MemoryAddress address, bool write, std::size_t size, const std::vector< MAU > *data=NULL)

void	addProcedureEntry (ClockCycleCount cycle, InstructionAddress address)

void	addProcedureExit (ClockCycleCount cycle, InstructionAddress address)

void	addBusActivity (ClockCycleCount cycle, const BusID &busId, const SegmentID &segmentId, bool squash, const SimValue &data=NullSimValue::instance())

void	addConcurrentRegisterFileAccessCount (RegisterFileID registerFile, RegisterAccessCount reads, RegisterAccessCount writes, ClockCycleCount count)

void	addRegisterAccessCount (RegisterFileID registerFile, RegisterID registerIndex, ClockCycleCount reads, ClockCycleCount writes)

ConcurrentRFAccessCountList *	registerFileAccessCounts (RegisterFileID registerFile) const

void	addFunctionUnitOperationTriggerCount (FunctionUnitID functionUnit, OperationID operation, OperationTriggerCount count)

void	addProcedureTransfer (ClockCycleCount cycle, InstructionAddress address, InstructionAddress sourceAddress, ProcedureEntryType type)

FUOperationTriggerCountList *	functionUnitOperationTriggerCounts (FunctionUnitID functionUnit) const

void	addSocketWriteCount (SocketID socket, ClockCycleCount)

ClockCycleCount	socketWriteCount (SocketID socket) const

void	addBusWriteCount (BusID socket, ClockCycleCount count)

ClockCycleCount	busWriteCount (BusID bus) const

void	setSimulatedCycleCount (ClockCycleCount count)

ClockCycleCount	simulatedCycleCount () const

InstructionExecution &	instructionExecutions ()

virtual	~ExecutionTrace ()

Static Public Member Functions
static ExecutionTrace *	open (const std::string &fileName)

Protected Member Functions
	ExecutionTrace (const std::string &fileName, bool readOnly)

void	open ()

Private Member Functions
void	initialize ()

Private Attributes
const std::string &	fileName_
	Filename of the trace database (sqlite file). More...

std::fstream	callTrace_
	The call trace file. More...

std::fstream	instructionProfile_
	The instruction profile file. More...

bool	readOnly_
	Is the database access mode read-only? More...

RelationalDB *	db_
	Handle to the sqlite trace database. More...

RelationalDBConnection *	dbConnection_
	Handle to the database connection;. More...

InstructionExecution *	instructionExecution_
	Handle object for the queries of instruction executions. More...

Detailed Description

The main class of the Execution Trace Database (TraceDB).

Access to the execution trace database happens through the interface of this class.

Definition at line 56 of file ExecutionTrace.hh.

Member Typedef Documentation

◆ AddressSpaceID

typedef std::string ExecutionTrace::AddressSpaceID

a type for storing address space identifiers

Definition at line 60 of file ExecutionTrace.hh.

◆ BusID

typedef std::string ExecutionTrace::BusID

a type for storing bus identifiers

Definition at line 63 of file ExecutionTrace.hh.

◆ ConcurrentRFAccessCount

typedef boost::tuple< RegisterAccessCount, RegisterAccessCount, ClockCycleCount> ExecutionTrace::ConcurrentRFAccessCount

type to be used as a key for storing concurrent RF access info

Definition at line 105 of file ExecutionTrace.hh.

◆ ConcurrentRFAccessCountList

typedef std::list<ConcurrentRFAccessCount> ExecutionTrace::ConcurrentRFAccessCountList

type to be used for a list of concurrent RF accesses

Definition at line 108 of file ExecutionTrace.hh.

◆ FunctionUnitID

typedef std::string ExecutionTrace::FunctionUnitID

a type for storing function unit identifiers

Definition at line 72 of file ExecutionTrace.hh.

◆ FUOperationTriggerCount

typedef boost::tuple<OperationID, OperationTriggerCount> ExecutionTrace::FUOperationTriggerCount

type to be used as a key for storing function unit operation execution counts

Definition at line 113 of file ExecutionTrace.hh.

◆ FUOperationTriggerCountList

typedef std::list<FUOperationTriggerCount> ExecutionTrace::FUOperationTriggerCountList

type to be used for lists of function operation execution counts

Definition at line 116 of file ExecutionTrace.hh.

◆ MAU

typedef SimValue ExecutionTrace::MAU

a type for storing data of size of the minimum addressable unit

Definition at line 87 of file ExecutionTrace.hh.

◆ MemoryAddress

typedef unsigned int ExecutionTrace::MemoryAddress

a type for storing memory addresses

Definition at line 84 of file ExecutionTrace.hh.

◆ OperationID

typedef std::string ExecutionTrace::OperationID

a type for storing operation identifiers

Definition at line 75 of file ExecutionTrace.hh.

◆ OperationTriggerCount

typedef ClockCycleCount ExecutionTrace::OperationTriggerCount

a type for operation trigger counts

Definition at line 93 of file ExecutionTrace.hh.

◆ RegisterAccessCount

typedef std::size_t ExecutionTrace::RegisterAccessCount

a type for register access counts

Definition at line 90 of file ExecutionTrace.hh.

◆ RegisterFileID

typedef std::string ExecutionTrace::RegisterFileID

a type for storing register file identifiers

Definition at line 78 of file ExecutionTrace.hh.

◆ RegisterID

typedef int ExecutionTrace::RegisterID

a type for storing register ids

Definition at line 81 of file ExecutionTrace.hh.

◆ SegmentID

typedef std::string ExecutionTrace::SegmentID

a type for storing bus segment identifiers

Definition at line 69 of file ExecutionTrace.hh.

◆ SocketID

typedef std::string ExecutionTrace::SocketID

a type for storing socket identifiers

Definition at line 66 of file ExecutionTrace.hh.

Member Enumeration Documentation

◆ ProcedureEntryType

enum ExecutionTrace::ProcedureEntryType

a type for storing procedure entry type (entry/exit)

Enumerator
PT_ENTRY	procedure entry
PT_EXIT	procedure exit

Definition at line 96 of file ExecutionTrace.hh.

                             {
         PT_ENTRY = 0, ///< procedure entry
         PT_EXIT = 1  ///< procedure exit
     };

Constructor & Destructor Documentation

◆ ~ExecutionTrace()

ExecutionTrace::~ExecutionTrace ( )

virtual

Destructor.

Closes the database and frees the resources connected to it. Commits the transaction so updates are written to disk.

Definition at line 202 of file ExecutionTrace.cc.

                                 {
  
     try {
         if (instructionExecution_ != NULL) {
             delete instructionExecution_;
             instructionExecution_ = NULL;
         }
  
         if (dbConnection_ != NULL) {
             dbConnection_->commit();
             try {
                 assert(db_ != NULL);
                 db_->close(*dbConnection_);
                 dbConnection_ = NULL;
             } catch (const RelationalDBException& e) {
                 Application::writeToErrorLog(
                     __FILE__, __LINE__, __func__, e.errorMessage());
             }
         }
  
         callTrace_.close();
         instructionProfile_.close();
  
         if (db_ != NULL) {
             delete db_;
             db_ = NULL;
         }
     
     } catch (const Exception& e) {
         debugLog(
             "Exception almost leaked from ~ExecutionTrace! Message: " +
             e.errorMessage());
     }
 }

References __func__, assert, callTrace_, RelationalDB::close(), RelationalDBConnection::commit(), db_, dbConnection_, debugLog, Exception::errorMessage(), instructionExecution_, instructionProfile_, and Application::writeToErrorLog().

Here is the call graph for this function:

◆ ExecutionTrace()

ExecutionTrace::ExecutionTrace	(	const std::string &	fileName,
		bool	readOnly
	)

protected

Constructor.

Parameters

fileName	Filename used for accessing the database.
readOnly	Is the database read-only?

Definition at line 180 of file ExecutionTrace.cc.

                                                                        : 
     fileName_(fileName), callTrace_(
         (fileName + ".calls").c_str(), 
         (FileSystem::fileExists(fileName) || readOnly) ? 
         std::fstream::in : 
         std::fstream::out | std::fstream::trunc),
     instructionProfile_(
         (fileName + ".profile").c_str(), 
         (FileSystem::fileExists(fileName) || readOnly) ? 
         std::fstream::in : 
         std::fstream::out | std::fstream::trunc),
     readOnly_(readOnly), db_(new SQLite()), 
     dbConnection_(NULL), instructionExecution_(NULL)  {
 }

Referenced by open().

Member Function Documentation

◆ addBasicBlockStart()

void ExecutionTrace::addBasicBlockStart	(	ClockCycleCount	cycle,
		InstructionAddress	address
	)

◆ addBusActivity()

void ExecutionTrace::addBusActivity	(	ClockCycleCount	cycle,
		const BusID &	busId,
		const SegmentID &	segmentId,
		bool	squash,
		const SimValue &	data = `NullSimValue::instance()`
	)

Adds a new bus activity record to the database.

Parameters

cycle	The clock cycle in which the bus activity happened.
busId	The name of the bus.
segmentId	The name of the segment in the bus.
squash	Whether the transfer was squashed or not.
data	The data transferred.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 391 of file ExecutionTrace.cc.

                                        {
     std::string query = 
         "INSERT INTO bus_activity(cycle, bus, segment, squash, "
         "data_as_int, data_as_double) VALUES(" + 
         Conversion::toString(cycle) + ", '" + busId + "', '" + segmentId + 
         "', ";
  
     if (squash) 
         query += "'TRUE'";
     else
         query += "'FALSE'";
  
     std::string doubleString = Conversion::toString(data.doubleWordValue());
     if (doubleString == "nan")
         doubleString = "NULL";
  
     if (!squash && &data != &NullSimValue::instance())
         query += ", " + Conversion::toString(data.uIntWordValue()) + ", " + 
             doubleString + ")";        
     else
         query += ", 0, 0.0)";
  
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         debugLog(std::string("query: ") + query);
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, debugLog, SimValue::doubleWordValue(), Exception::errorMessage(), NullSimValue::instance(), Conversion::toString(), SimValue::uIntWordValue(), and RelationalDBConnection::updateQuery().

Here is the call graph for this function:

◆ addBusWriteCount()

void ExecutionTrace::addBusWriteCount	(	BusID	bus,
		ClockCycleCount	count
	)

Adds a bus write count statistics to the database.

This stats tells in how many clock cycles was a bus used (transported data through).

Parameters

socket	The name of the bus.
count	The count of writes/uses.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 688 of file ExecutionTrace.cc.

                                                                  {
     const std::string query =
         std::string("") +
         "INSERT INTO bus_write_counts(bus, writes) "
         "VALUES('" + bus + "', " + Conversion::toString(count) + ")";
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         debugLog(query + " failed!");
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ addConcurrentRegisterFileAccessCount()

void ExecutionTrace::addConcurrentRegisterFileAccessCount	(	RegisterFileID	registerFile,
		RegisterAccessCount	reads,
		RegisterAccessCount	writes,
		ClockCycleCount	count
	)

Adds a concurrent register file access statistics to the database.

Statistics tells how many times a type of read/write count combination access happened. That is, how many times the given register file was read and written the given times simultaneously.

Parameters

registerFile	The name of the register file.
reads	Count of simultaneous reads.
writes	Count of simultaneous writes.
count	The count of this type of accesses.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 440 of file ExecutionTrace.cc.

                                                        {
     const std::string query =
         std::string("") +
         "INSERT INTO concurrent_register_file_access("
         "                register_file, reads, writes, count) "
         "VALUES('" + registerFile + "', " +
         Conversion::toString(reads) + ", " +
         Conversion::toString(writes) + ", " +
         Conversion::toString(count) + ")";
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         debugLog(query + " failed!");
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ addFunctionUnitOperationTriggerCount()

void ExecutionTrace::addFunctionUnitOperationTriggerCount	(	FunctionUnitID	functionUnit,
		OperationID	operation,
		OperationTriggerCount	count
	)

Adds a function unit operation execution statistics to the database.

Statistics tells how many times an operation was executed in an function unit.

Parameters

functionUnit	The name of the function unit.
operation	The name of the operation.
count	The count of executions.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 546 of file ExecutionTrace.cc.

                                  {
     const std::string query =
         std::string("") +
         "INSERT INTO fu_operation_triggers("
         "                function_unit, operation, count) "
         "VALUES('" + functionUnit + "', '" + operation + "', " +
         Conversion::toString(count) + ")";
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         debugLog(query + " failed!");
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ addInstructionExecution()

void ExecutionTrace::addInstructionExecution	(	ClockCycleCount	cycle,
		InstructionAddress	address
	)

Adds a new instruction execution record to the database.

Parameters

cycle	The clock cycle on which the instruction execution happened.
address	The address of the executed instruction.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 279 of file ExecutionTrace.cc.

                                                        {
     const std::string query =
       (boost::format(
         "INSERT INTO instruction_execution(cycle, address) VALUES(" 
     "%.0f, %d);") % cycle % address).str();
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, Exception::errorMessage(), and RelationalDBConnection::updateQuery().

Referenced by ExecutionTracker::handleEvent().

Here is the call graph for this function:

◆ addInstructionExecutionCount()

void ExecutionTrace::addInstructionExecutionCount	(	InstructionAddress	address,
		ClockCycleCount	count
	)

Adds a new instruction execution count record to the database.

Parameters

address	The address of the executed instruction.
count	The count of clock cycles during which execution of the instruction happened.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 304 of file ExecutionTrace.cc.

                                                        {
     instructionProfile_ << address << "\t" << count << std::endl;
 #if 0
     const std::string query =
         "INSERT INTO instruction_execution_count(address, count) VALUES(" + 
         Conversion::toString(address) + ", " + 
         Conversion::toString(count) + ");";
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 #endif
 }

References __func__, assert, dbConnection_, Exception::errorMessage(), instructionProfile_, Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ addLockedCycle()

void ExecutionTrace::addLockedCycle ( ClockCycleCount cycle )

◆ addMemoryAccess()

void ExecutionTrace::addMemoryAccess	(	ClockCycleCount	cycle,
		const AddressSpaceID &	addressSpace,
		MemoryAddress	address,
		bool	write,
		std::size_t	size,
		const std::vector< MAU > *	data = `NULL`
	)

◆ addProcedureAddressRange()

void ExecutionTrace::addProcedureAddressRange	(	InstructionAddress	firstAddress,
		InstructionAddress	lastAddress,
		const std::string &	procedureName
	)

Adds a procedure address range entry to the database.

An entry in this table tells the range of instruction addresses belonging to a procedure.

Parameters

firstAddress	The starting address of the procedure.
lastAddress	The ending address of the procedure.
name	The name of the procedure.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 335 of file ExecutionTrace.cc.

                                     {
     const std::string query =
         "INSERT INTO procedure_address_range(first_address, last_address, "
         "procedure_name) VALUES(" + 
         Conversion::toString(firstAddress) + ", " + 
         Conversion::toString(lastAddress) + ", '" + 
         procedureName + "');";
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ addProcedureEntry()

void ExecutionTrace::addProcedureEntry	(	ClockCycleCount	cycle,
		InstructionAddress	address
	)

◆ addProcedureExit()

void ExecutionTrace::addProcedureExit	(	ClockCycleCount	cycle,
		InstructionAddress	address
	)

◆ addProcedureTransfer()

void ExecutionTrace::addProcedureTransfer	(	ClockCycleCount	cycle,
		InstructionAddress	address,
		InstructionAddress	sourceAddress,
		ProcedureEntryType	type
	)

Adds a procedure transfer tracking data entry.

Parameters

cycle	The clock cycle in which the transfer occured.
address	The instruction address to which the execution changed.
callAddress	The address of the call.
type	Type of the transfer.

Definition at line 575 of file ExecutionTrace.cc.

                                                                {
     callTrace_ 
         << cycle << "\t" << address << "\t" << sourceAddress << "\t" 
         << type << std::endl;
 }

References callTrace_.

Referenced by ProcedureTransferTracker::addProcedureTransfer().

◆ addRegisterAccessCount()

void ExecutionTrace::addRegisterAccessCount	(	RegisterFileID	registerFile,
		RegisterID	registerIndex,
		ClockCycleCount	reads,
		ClockCycleCount	writes
	)

Adds a register access statistics to the database.

Statistics tells how many times a register was read and written during simulation.

Parameters

registerFile	The name of the register file.
registerIndex	The index of the register.
reads	Count of reads.
writes	Count of writes.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 475 of file ExecutionTrace.cc.

                                                    {
     const std::string query =
         (boost::format(
             "INSERT INTO register_access("
             "                register_file, register_index, reads, writes) "
             "VALUES('%s', %d, %.0f, %.0f)") 
          % registerFile % registerIndex % reads % writes).str();
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         debugLog(query + " failed!");
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, debugLog, Exception::errorMessage(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ addSocketWriteCount()

void ExecutionTrace::addSocketWriteCount	(	SocketID	socket,
		ClockCycleCount	count
	)

Adds a socket write count statistics to the database.

This stats tells in how many clock cycles was a socket used (transported data through).

Parameters

socket	The name of the socket.
count	The count of writes/uses.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 631 of file ExecutionTrace.cc.

                                                                           {
     const std::string query =
         std::string("") +
         "INSERT INTO socket_write_counts(socket, writes) "
         "VALUES('" + socket + "', " + Conversion::toString(count) + ")";
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         debugLog(query + " failed!");
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ busWriteCount()

ClockCycleCount ExecutionTrace::busWriteCount ( BusID bus ) const

Returns the count of clock cycles in which a bus was written to.

In case no data was found for the given bus in DB, returns 0.

Parameters

bus	The name of the bus.

Returns: The count of writes/accesses.

Definition at line 713 of file ExecutionTrace.cc.

                                              {
  
     RelationalDBQueryResult* result = NULL;
     ClockCycleCount count = 0;
     try {
         result = dbConnection_->query(
             (boost::format(
                 "SELECT writes FROM bus_write_counts "
                 "WHERE bus LIKE('%s')") % bus).str());
  
         if (result->hasNext()) {
             result->next();
             count = (result->data("writes")).integerValue();
         }
     } catch (const Exception&) {
     } 
     delete result;
     result = NULL;
     return count;
 }

References RelationalDBQueryResult::data(), dbConnection_, RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by DefaultICDecoderEstimator::estimateICEnergy().

Here is the call graph for this function:

◆ functionUnitOperationTriggerCounts()

ExecutionTrace::FUOperationTriggerCountList * ExecutionTrace::functionUnitOperationTriggerCounts ( FunctionUnitID functionUnit ) const

Returns the list of operation access counts for wanted function unit.

Parameters

functionUnit The function unit for which the stats are needed.

Returns: A list of access counts. Must be deleted by the client after use.

Exceptions

IOException If an I/O error occurs.

Definition at line 591 of file ExecutionTrace.cc.

                                        {
     FUOperationTriggerCountList* accesses = NULL;
     try {
         assert(dbConnection_ != NULL);
  
         RelationalDBQueryResult* result =
             dbConnection_->query(
                 std::string("") +
                 "SELECT * FROM fu_operation_triggers WHERE function_unit "
                 "LIKE('" + functionUnit + "')");
         accesses = new FUOperationTriggerCountList();
         while (result->hasNext()) {
             result->next();
             accesses->push_back(
                 boost::make_tuple(
                     (result->data("operation")).stringValue(),
                     (result->data("count")).integerValue()));
         }
         delete result;
         result = NULL;
     } catch (const Exception& e) {
         delete accesses;
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
  
     return accesses;
 }

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by StrictMatchFUEstimator::estimateEnergy(), and InterpolatingFUEstimator::estimateEnergy().

Here is the call graph for this function:

◆ initialize()

void ExecutionTrace::initialize ( )

private

Initializes a new trace database.

Exceptions

IOException If an I/O error occured.

Definition at line 243 of file ExecutionTrace.cc.

                            {
     assert(dbConnection_ != NULL);
     
     try {
         dbConnection_->DDLQuery(CQ_DATABASE_INFO);
         dbConnection_->DDLQuery(CQ_INSTRUCTION_EXECUTION);
         dbConnection_->DDLQuery(CQ_PROCEDURE_ADDRESS_RANGE);
         dbConnection_->DDLQuery(CQ_BUS_ACTIVITY);
         dbConnection_->DDLQuery(CQ_REGISTER_ACCESS);
         dbConnection_->DDLQuery(CQ_CONCURRENT_REGISTER_FILE_ACCESS);
         dbConnection_->DDLQuery(CQ_TOTALS);
         dbConnection_->DDLQuery(CQ_FU_OPERATION_TRIGGERS);
         dbConnection_->DDLQuery(CQ_BUS_WRITE_COUNTS);
         dbConnection_->DDLQuery(CQ_SOCKET_WRITE_COUNTS);
  
         dbConnection_->updateQuery(
             (boost::format(
                 "INSERT INTO database_info(version) VALUES (%d);") %
              DB_VERSION).str());
  
     } catch (const RelationalDBException& e) {
         debugLog(
             std::string("") + "Error while initializing TraceDB. " +
             e.errorMessage());
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, CQ_BUS_ACTIVITY, CQ_BUS_WRITE_COUNTS, CQ_CONCURRENT_REGISTER_FILE_ACCESS, CQ_DATABASE_INFO, CQ_FU_OPERATION_TRIGGERS, CQ_INSTRUCTION_EXECUTION, CQ_PROCEDURE_ADDRESS_RANGE, CQ_REGISTER_ACCESS, CQ_SOCKET_WRITE_COUNTS, CQ_TOTALS, DB_VERSION, dbConnection_, RelationalDBConnection::DDLQuery(), debugLog, Exception::errorMessage(), and RelationalDBConnection::updateQuery().

Referenced by open().

Here is the call graph for this function:

◆ instructionExecutions()

InstructionExecution & ExecutionTrace::instructionExecutions ( )

Queries database for instruction execution entries.

Returns: A handle object which can be used to traverse through the results. The handle points to the first instruction execution in the list of executions, sorted by the cycle.

Exceptions

IOException If an I/O error occurs.

Definition at line 363 of file ExecutionTrace.cc.

                                       {
     if (instructionExecution_ != NULL) {
         delete instructionExecution_;
         instructionExecution_ = NULL;
     }
  
     try {
         instructionExecution_ = new InstructionExecution(
             dbConnection_->query(
                 "SELECT * FROM instruction_execution ORDER BY cycle"));
     } catch (const Exception& e) {
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     } 
  
     return *instructionExecution_;
 }

References __func__, dbConnection_, Exception::errorMessage(), instructionExecution_, and RelationalDBConnection::query().

Referenced by open().

Here is the call graph for this function:

◆ open() [1/2]

void ExecutionTrace::open ( )

protected

Initializes the trace files.

For the traceDB sqlite file, starts a new transaction. Transaction is committed in destructor. This consumes lots of memory but should reduce I/O to the minimum.

Definition at line 169 of file ExecutionTrace.cc.

                      {
     dbConnection_ = &db_->connect(fileName_);
     dbConnection_->beginTransaction();
 }

References RelationalDBConnection::beginTransaction(), RelationalDB::connect(), db_, dbConnection_, and fileName_.

Referenced by SimulatorFrontend::initializeTracing(), and loadInputs().

Here is the call graph for this function:

◆ open() [2/2]

ExecutionTrace * ExecutionTrace::open ( const std::string & fileName )

static

Creates a new execution trace database.

If the database file cannot be found, creates a new database file and initializes it. Some of the bigger traces are written to separate ascii files to speed up trace generation.

The filenames are formed as follows:

fileName The main traceDB relational database file, always created (e.g. foobar.tpef.1.trace). fileName.calls The call trace, produced with 'procedure_transfer_tracking' setting of ttasim (e.g. foobar.tpef.1.trace.calls). fileName.profile The instruction execution counts, produced with 'profile_data_saving' setting of ttasim (e.g. foobar.tpef.1.trace.profile).

Parameters

fileName Full path to the traceDB file to be opened.

Returns: A pointer to opened execution trace database instance. Instance is owned by the client and should be deleted after use.

Exceptions

IOException If there was a problem opening the database, for example, if the file cannot be found and a new file cannot be created.

Definition at line 138 of file ExecutionTrace.cc.

                                               {
     ExecutionTrace* traceDB = 
         new ExecutionTrace(
             fileName, FileSystem::fileExists(fileName) && 
             !FileSystem::fileIsWritable(fileName));
     try {
         bool newDatabase = !FileSystem::fileExists(fileName);
         traceDB->open();
         if (newDatabase) {
             traceDB->initialize();  
         } else {
             // tests that the file is really a trace DB by querying the
             // instruction_execution table
             traceDB->instructionExecutions();
         }
     } catch (const RelationalDBException& e) {
         delete traceDB;
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
  
     return traceDB;
 }

References __func__, Exception::errorMessage(), ExecutionTrace(), FileSystem::fileExists(), FileSystem::fileIsWritable(), initialize(), instructionExecutions(), and open().

Referenced by open().

Here is the call graph for this function:

◆ registerFileAccessCounts()

ExecutionTrace::ConcurrentRFAccessCountList * ExecutionTrace::registerFileAccessCounts ( RegisterFileID registerFile ) const

Returns the list of different concurrent register file access combinations and counts how many times those were encountered while simulating the program.

Parameters

registerFile The register file for which the stats are needed.

Returns: A list of accesses. Must be deleted by the client after use.

Exceptions

IOException If an I/O error occurs.

Definition at line 505 of file ExecutionTrace.cc.

                                                                           {
     ConcurrentRFAccessCountList* accesses = NULL;
     try {
         assert(dbConnection_ != NULL);
  
         RelationalDBQueryResult* result =
             dbConnection_->query(
                 std::string("") +
                 "SELECT * FROM concurrent_register_file_access " +
                 "WHERE register_file LIKE('" + registerFile + "')");
         accesses = new ConcurrentRFAccessCountList();
         while (result->hasNext()) {
             result->next();
             accesses->push_back(
                 boost::make_tuple(
                     (result->data("reads")).integerValue(),
                     (result->data("writes")).integerValue(),
                     (result->data("count")).integerValue()));
         }
         delete result;
         result = NULL;
     } catch (const Exception& e) {
         delete accesses;
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
  
     return accesses;
 }

References __func__, assert, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by StrictMatchRFEstimator::estimateEnergy(), and InterpolatingRFEstimator::estimateEnergy().

Here is the call graph for this function:

◆ setSimulatedCycleCount()

void ExecutionTrace::setSimulatedCycleCount ( ClockCycleCount count )

Sets the total count of simulated clock cycles.

Parameters

count The count of cycles.

Exceptions

IOException In case an error in adding the data happened.

Definition at line 741 of file ExecutionTrace.cc.

                                                             {
     const std::string query =
         std::string("") +
         "INSERT INTO totals(value_name, integer_value) "
         "VALUES('cycle_count', " + Conversion::toString(count) + ")";
  
     assert(dbConnection_ != NULL);
  
     try {
         dbConnection_->updateQuery(query);
     } catch (const RelationalDBException& e) {
         debugLog(query + " failed!");
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, assert, dbConnection_, debugLog, Exception::errorMessage(), Conversion::toString(), and RelationalDBConnection::updateQuery().

Referenced by SimulatorFrontend::finishSimulation().

Here is the call graph for this function:

◆ simulatedCycleCount()

ClockCycleCount ExecutionTrace::simulatedCycleCount ( ) const

Gets the total count of simulated clock cycles.

Returns: The count of cycles.

Exceptions

IOException In case an error in getting the data happened.

Definition at line 764 of file ExecutionTrace.cc.

                                           {
     RelationalDBQueryResult* result = NULL;
     try {
         result = dbConnection_->query(
             "SELECT integer_value FROM totals "
             "WHERE value_name LIKE('cycle_count')");
         if (!result->hasNext()) {
             delete result;
             result = NULL;
             throw IOException(
                 __FILE__, __LINE__, __func__, 
                 "No 'cycle_count' entry in 'totals' table.");
         }
         result->next();
         ClockCycleCount count = (result->data("integer_value")).integerValue();
         delete result;
         result = NULL;
         return count;
     } catch (const Exception& e) {
         delete result;
         result = NULL;
         throw IOException(__FILE__, __LINE__, __func__, e.errorMessage());
     }
 }

References __func__, RelationalDBQueryResult::data(), dbConnection_, Exception::errorMessage(), RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by StrictMatchFUEstimator::estimateEnergy(), StrictMatchRFEstimator::estimateEnergy(), InterpolatingFUEstimator::estimateEnergy(), InterpolatingRFEstimator::estimateEnergy(), and DefaultICDecoderEstimator::estimateICEnergy().

Here is the call graph for this function:

◆ socketWriteCount()

ClockCycleCount ExecutionTrace::socketWriteCount ( SocketID socket ) const

Returns the count of clock cycles in which a socket was written to.

In case no data was found for the given socket in DB, returns 0.

Parameters

socket The name of the socket.

Returns: The count of writes/accesses.

Definition at line 656 of file ExecutionTrace.cc.

                                                       {
  
     RelationalDBQueryResult* result = NULL;
     ClockCycleCount count = 0;
     try {
         result = dbConnection_->query(
             (boost::format(
                 "SELECT writes FROM socket_write_counts "
                 "WHERE socket LIKE('%s')") % socket).str());
  
         if (result->hasNext()) {
             result->next();
             count = (result->data("writes")).integerValue();
         }
     } catch (const Exception&) {
     } 
     delete result;
     result = NULL;
     return count;
 }

References RelationalDBQueryResult::data(), dbConnection_, RelationalDBQueryResult::hasNext(), RelationalDBQueryResult::next(), and RelationalDBConnection::query().

Referenced by DefaultICDecoderEstimator::estimateICEnergy().

Here is the call graph for this function:

Member Data Documentation

◆ callTrace_

std::fstream ExecutionTrace::callTrace_

private

The call trace file.

Definition at line 199 of file ExecutionTrace.hh.

Referenced by addProcedureTransfer(), and ~ExecutionTrace().

◆ db_

RelationalDB* ExecutionTrace::db_

private

Handle to the sqlite trace database.

Definition at line 205 of file ExecutionTrace.hh.

Referenced by open(), and ~ExecutionTrace().

◆ dbConnection_

RelationalDBConnection* ExecutionTrace::dbConnection_

private

Handle to the database connection;.

Definition at line 207 of file ExecutionTrace.hh.

Referenced by addBusActivity(), addBusWriteCount(), addConcurrentRegisterFileAccessCount(), addFunctionUnitOperationTriggerCount(), addInstructionExecution(), addInstructionExecutionCount(), addProcedureAddressRange(), addRegisterAccessCount(), addSocketWriteCount(), busWriteCount(), functionUnitOperationTriggerCounts(), initialize(), instructionExecutions(), open(), registerFileAccessCounts(), setSimulatedCycleCount(), simulatedCycleCount(), socketWriteCount(), and ~ExecutionTrace().

◆ fileName_

const std::string& ExecutionTrace::fileName_

private

Filename of the trace database (sqlite file).

Definition at line 197 of file ExecutionTrace.hh.

Referenced by open().

◆ instructionExecution_

InstructionExecution* ExecutionTrace::instructionExecution_

private

Handle object for the queries of instruction executions.

Definition at line 209 of file ExecutionTrace.hh.

Referenced by instructionExecutions(), and ~ExecutionTrace().

◆ instructionProfile_

std::fstream ExecutionTrace::instructionProfile_

private

The instruction profile file.

Definition at line 201 of file ExecutionTrace.hh.

Referenced by addInstructionExecutionCount(), and ~ExecutionTrace().

◆ readOnly_

bool ExecutionTrace::readOnly_

private

Is the database access mode read-only?

Definition at line 203 of file ExecutionTrace.hh.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ AddressSpaceID

◆ BusID

◆ ConcurrentRFAccessCount

◆ ConcurrentRFAccessCountList

◆ FunctionUnitID

◆ FUOperationTriggerCount

◆ FUOperationTriggerCountList

◆ MAU

◆ MemoryAddress

◆ OperationID

◆ OperationTriggerCount

◆ RegisterAccessCount

◆ RegisterFileID

◆ RegisterID

◆ SegmentID

◆ SocketID

Member Enumeration Documentation

◆ ProcedureEntryType

Constructor & Destructor Documentation

◆ ~ExecutionTrace()

◆ ExecutionTrace()

Member Function Documentation

◆ addBasicBlockStart()

◆ addBusActivity()

◆ addBusWriteCount()

◆ addConcurrentRegisterFileAccessCount()

◆ addFunctionUnitOperationTriggerCount()

◆ addInstructionExecution()

◆ addInstructionExecutionCount()

◆ addLockedCycle()

◆ addMemoryAccess()

◆ addProcedureAddressRange()

◆ addProcedureEntry()

◆ addProcedureExit()

◆ addProcedureTransfer()

◆ addRegisterAccessCount()

◆ addSocketWriteCount()

◆ busWriteCount()

◆ functionUnitOperationTriggerCounts()

◆ initialize()

◆ instructionExecutions()

◆ open() [1/2]

◆ open() [2/2]

◆ registerFileAccessCounts()

◆ setSimulatedCycleCount()

◆ simulatedCycleCount()

◆ socketWriteCount()

Member Data Documentation

◆ callTrace_

◆ db_

◆ dbConnection_

◆ fileName_

◆ instructionExecution_

◆ instructionProfile_

◆ readOnly_