OperationPoolPimpl Class Reference

#include <OperationPoolPimpl.hh>

Collaboration diagram for OperationPoolPimpl:

Public Member Functions
	~OperationPoolPimpl ()
Operation &	operation (const char *name)
OperationIndex &	index ()
bool	sharesState (const Operation &op)

Static Public Member Functions
static void	cleanupCache ()
static void	setLLVMTargetInstrInfo (const llvm::MCInstrInfo *tid)

Private Types
typedef std::map< std::string, Operation * >	OperationTable
	Container for operations indexed by their names.

Private Member Functions
	OperationPoolPimpl ()
	OperationPoolPimpl (const OperationPoolPimpl &)
	Copying not allowed.
OperationPoolPimpl &	operator= (const OperationPoolPimpl &)
	Assignment not allowed.
Operation *	loadFromLLVM (const llvm::MCInstrDesc &tid)

Private Attributes
OperationSerializer	serializer_

Static Private Attributes
static OperationBehaviorLoader *	loader_
	Operation pool uses this to load behavior models of the operations.
static OperationIndex *	index_
	Indexed table used to find out which operation module contains the given operation.
static OperationTable	operationCache_
	Contains all operations that have been already requested by the client.
static std::vector< OperationBehaviorProxy * >	proxies_
	Contains all operation behavior proxies.
static const llvm::MCInstrInfo *	llvmTargetInstrInfo_
	If this is set, OSAL data is loaded from the TargetInstrInfo instead of .opp XML files. Used when calling the TCE scheduler from non-TTA LLVM targets.

Friends
class	OperationPool

Detailed Description

A private implementation class for OperationPool

Definition at line 53 of file OperationPoolPimpl.hh.

Member Typedef Documentation

OperationTable

typedef std::map<std::string, Operation*> OperationPoolPimpl::OperationTable

private

Container for operations indexed by their names.

Definition at line 71 of file OperationPoolPimpl.hh.

Constructor & Destructor Documentation

~OperationPoolPimpl()

OperationPoolPimpl::~OperationPoolPimpl

(

)

The destructor

Definition at line 90 of file OperationPoolPimpl.cc.

                                        {
}

OperationPoolPimpl() [1/2]

OperationPoolPimpl::OperationPoolPimpl ( )

private

The constructor

Definition at line 75 of file OperationPoolPimpl.cc.

                                       {
    // if this is a first created instance of OperationPool,
    // initialize the OperationIndex instance with the search paths
    if (index_ == NULL) {
        index_ = new OperationIndex();
        vector<string> paths = Environment::osalPaths();
        for (unsigned int i = 0; i < paths.size(); i++) {
            index_->addPath(paths[i]);
        }
    }
}

References OperationIndex::addPath(), index_, and Environment::osalPaths().

Here is the call graph for this function:

OperationPoolPimpl() [2/2]

OperationPoolPimpl::OperationPoolPimpl ( const OperationPoolPimpl &  )

private

Copying not allowed.

Member Function Documentation

cleanupCache()

void OperationPoolPimpl::cleanupCache ( )

static

Cleans up the static Operation cache.

Deletes also the Operation instances, so be sure you are not using them after calling this!

Definition at line 100 of file OperationPoolPimpl.cc.

                                 {
    AssocTools::deleteAllValues(operationCache_);
    delete index_;
    index_ = NULL;
}

References AssocTools::deleteAllValues(), index_, and operationCache_.

Referenced by OperationPool::cleanupCache().

Here is the call graph for this function:

index()

OperationIndex & OperationPoolPimpl::index

(

)

Returns the operation index of operation pool.

Returns

The operation index.

Definition at line 213 of file OperationPoolPimpl.cc.

                          {
    assert(index_ != NULL);
    return *index_;
}

References assert, and index_.

Referenced by OperationPool::index().

loadFromLLVM()

Operation * OperationPoolPimpl::loadFromLLVM ( const llvm::MCInstrDesc &  tid )

private

Loads an OSAL Operation from LLVM TargetInstrDesc.

Used for avoiding the need for .xml OSAL databases when TCE scheduler is called directly for non-TTA LLVM targets.

Definition at line 164 of file OperationPoolPimpl.cc.

  {
    TCEString opName = llvmTargetInstrInfo_->getName(tid.getOpcode()).str();
    Operation* op = new Operation(opName, NullOperationBehavior::instance());
   
    unsigned outputs = tid.getNumDefs();
    unsigned inputs = tid.getNumOperands() - outputs;
 
    // at least a minimal implicit trigger input
    // RET of SPU does not include the implicit link register
    // operand even though it will be generated in the final 
    // assembly to just an absolute jump to it 
    if (inputs == 0) 
        inputs = 1; 
 
    for (unsigned opr = 0; opr < outputs; ++opr) {
        Operand* operand = 
            new Operand(false, inputs + opr + 1, Operand::UINT_WORD);
        op->addOutput(operand);
    }
 
    for (unsigned opr = 0; opr < inputs; ++opr) {
        Operand* operand = new Operand(true, opr + 1, Operand::UINT_WORD);
        op->addInput(operand);
    }
    if (tid.isCall()) {
        op->setCall(true);
        op->setControlFlowOperation(true);
    }
    if (tid.isBranch() || tid.isReturn()) {
        op->setBranch(true);
        op->setControlFlowOperation(true);        
    }
    if (tid.mayLoad()) {
        op->setReadsMemory(true);
    }
    if (tid.mayStore()) {
        op->setWritesMemory(true);
    }    
    return op;
}

References Operation::addInput(), Operation::addOutput(), NullOperationBehavior::instance(), llvmTargetInstrInfo_, Operation::setBranch(), Operation::setCall(), Operation::setControlFlowOperation(), Operation::setReadsMemory(), Operation::setWritesMemory(), and Operand::UINT_WORD.

Referenced by operation().

Here is the call graph for this function:

operation()

Operation & OperationPoolPimpl::operation

(

const char *

name

)

Looks up an operation identified by its name and returns a reference to it.

The first found operation is returned. If operation is not found, a null operation is returned.

Parameters

name	The name of the operation.

Returns

The wanted operation.

Definition at line 116 of file OperationPoolPimpl.cc.

                                              {
 
    OperationTable::iterator it =
        operationCache_.find(StringTools::stringToLower(name));
    if (it != operationCache_.end()) {
        return *((*it).second);
    }
 
    // If llvmTargetInstrInfo_ is set, the scheduler is called
    // directly from LLVM code gen. Use the TargetInstrDesc as
    // the source for operation info instead.
    if (llvmTargetInstrInfo_ != NULL) {
        for (unsigned opc = 0; opc < llvmTargetInstrInfo_->getNumOpcodes();
             ++opc) {
            const llvm::MCInstrDesc& tid = llvmTargetInstrInfo_->get(opc);
            TCEString operName =
                TCEString(llvmTargetInstrInfo_->getName(opc).str()).lower();
            if (operName == TCEString(name).lower()) {
                Operation* llvmOperation = loadFromLLVM(tid);
                operationCache_[operName] = llvmOperation;
                return *llvmOperation;
            }
        }
        abortWithError(
            TCEString("Did not find info for LLVM operation ") + name);
    }
 
    OperationModule& module = index_->moduleOf(name);
    if (&module == &NullOperationModule::instance()) {
        return NullOperation::instance();
    }
 
    Operation* effective = index_->effectiveOperation(name);
    if (effective != NULL) {
        operationCache_[StringTools::stringToLower(name)] = effective;
        return *effective;
    } else {
        return NullOperation::instance();            
    }
}

References abortWithError, OperationIndex::effectiveOperation(), index_, NullOperation::instance(), NullOperationModule::instance(), llvmTargetInstrInfo_, loadFromLLVM(), TCEString::lower(), operationCache_, and StringTools::stringToLower().

Referenced by OperationPool::operation().

Here is the call graph for this function:

operator=()

OperationPoolPimpl & OperationPoolPimpl::operator= ( const OperationPoolPimpl &  )

private

Assignment not allowed.

setLLVMTargetInstrInfo()

static void OperationPoolPimpl::setLLVMTargetInstrInfo ( const llvm::MCInstrInfo *  tid )

inlinestatic

Definition at line 64 of file OperationPoolPimpl.hh.

                                                                   {
        llvmTargetInstrInfo_ = tid;
    }

References llvmTargetInstrInfo_.

Referenced by OperationPool::setLLVMTargetInstrInfo().

sharesState()

bool OperationPoolPimpl::sharesState

(

const Operation &

op

)

Definition at line 219 of file OperationPoolPimpl.cc.

                                                   {
    if (op.affectsCount() > 0 || op.affectedByCount() > 0)
        return true;
    for (const auto& entry : operationCache_) {
        const Operation& other = *entry.second;
        if (other.dependsOn(op))
            return true;
    }
    return false;
}

References Operation::affectedByCount(), Operation::affectsCount(), Operation::dependsOn(), and operationCache_.

Referenced by OperationPool::sharesState().

Here is the call graph for this function:

Friends And Related Symbol Documentation

OperationPool

friend class OperationPool

friend

Definition at line 55 of file OperationPoolPimpl.hh.

Member Data Documentation

index_

OperationIndex * OperationPoolPimpl::index_

staticprivate

Indexed table used to find out which operation module contains the given operation.

Definition at line 82 of file OperationPoolPimpl.hh.

Referenced by cleanupCache(), index(), operation(), and OperationPoolPimpl().

llvmTargetInstrInfo_

const llvm::MCInstrInfo * OperationPoolPimpl::llvmTargetInstrInfo_

staticprivate

If this is set, OSAL data is loaded from the TargetInstrInfo instead of .opp XML files. Used when calling the TCE scheduler from non-TTA LLVM targets.

Definition at line 93 of file OperationPoolPimpl.hh.

Referenced by loadFromLLVM(), operation(), and setLLVMTargetInstrInfo().

loader_

OperationBehaviorLoader* OperationPoolPimpl::loader_

staticprivate

Operation pool uses this to load behavior models of the operations.

Definition at line 79 of file OperationPoolPimpl.hh.

operationCache_

OperationPoolPimpl::OperationTable OperationPoolPimpl::operationCache_

staticprivate

Contains all operations that have been already requested by the client.

Definition at line 87 of file OperationPoolPimpl.hh.

Referenced by cleanupCache(), operation(), and sharesState().

proxies_

std::vector<OperationBehaviorProxy*> OperationPoolPimpl::proxies_

staticprivate

Contains all operation behavior proxies.

Definition at line 89 of file OperationPoolPimpl.hh.

serializer_

OperationSerializer OperationPoolPimpl::serializer_

private

Definition at line 84 of file OperationPoolPimpl.hh.

---

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

• OperationPoolPimpl.hh
• OperationPoolPimpl.cc