#include <BlocksGCU.hh>

Collaboration diagram for BlocksGCU:

Public Member Functions
	BlocksGCU (TTAMachine::Machine &mach, const std::string &name, TTAMachine::AddressSpace &asInstr)

	~BlocksGCU ()

Public Attributes
TTAMachine::ControlUnit *	gcu

TTAMachine::FUPort *	pc

TTAMachine::FUPort *	val

TTAMachine::SpecialRegisterPort *	ra

TTAMachine::Socket *	raIn

TTAMachine::Socket *	raOut

TTAMachine::Socket *	pcIn

TTAMachine::Socket *	valIn

TTAMachine::Bus *	raBus

std::list< std::string >	sources

Private Member Functions
void	ConfigurePipeline (TTAMachine::ExecutionPipeline *pipeline, int numOfOperands)

void	BindPorts (TTAMachine::HWOperation *hwOp, int numOfOperands)

TTAMachine::HWOperation *	CreateHWOp (const std::string &name, int numOfOperands)

Private Attributes
std::vector< TTAMachine::HWOperation * >	ops

Detailed Description

Definition at line 46 of file BlocksGCU.hh.

Constructor & Destructor Documentation

◆ BlocksGCU()

BlocksGCU::BlocksGCU	(	TTAMachine::Machine &	mach,
		const std::string &	name,
		TTAMachine::AddressSpace &	asInstr
	)

BlocksGCU with default instructions

Parameters

mach	The TTA machine where the GCU(ABU) needs to be added.
name	The name of the GCU.
asInstr	The address space containing the program instructions.

Definition at line 44 of file BlocksGCU.cc.

                                                                  {
     int delaySlots = 2;
     int globalGuardLatency = 1;
     gcu = new ControlUnit(name, delaySlots, globalGuardLatency);
     mach.setGlobalControl(*gcu);
     gcu->setAddressSpace(&asInstr);
  
     // TODO(mm): add check if there is not already a GCU present
     pc = new FUPort("pc", 32, *gcu, true, true, true);
     val = new FUPort("value", 32, *gcu, false, false, true);
     ra = new SpecialRegisterPort("ra", 32, *gcu);
  
     // Create in and ouput sockets for 'special RA port'
     raIn = new Socket("raIn");
     raOut = new Socket("abu_out0");
     valIn = new Socket("value");
     pcIn = new Socket("pc");
     mach.addSocket(*raIn);
     mach.addSocket(*raOut);
     mach.addSocket(*valIn);
     mach.addSocket(*pcIn);
     ra->attachSocket(*raIn);
     ra->attachSocket(*raOut);
     pc->attachSocket(*pcIn);
     val->attachSocket(*valIn);
  
     // Connect in and out socket to bus
     const int busWidth = 32;
     const int immWidth = 0;
     Machine::Extension busExt = Machine::Extension::ZERO;
     Bus* raBus = new Bus("ra_out_to_ra_in", busWidth, immWidth, busExt);
     mach.addBus(*raBus);
     new UnconditionalGuard(false, *raBus);
     new Segment("seg1", *raBus);
     raIn->attachBus(*raBus);
     raOut->attachBus(*raBus);
     pcIn->attachBus(*raBus);
     raOut->setDirection(Socket::Direction::OUTPUT);
  
     // set RA port
     gcu->setReturnAddressPort(*ra);
  
     // Add HWops
     ops.push_back(CreateHWOp("bnz", 2));
     ops.push_back(CreateHWOp("bz", 2));
     ops.push_back(CreateHWOp("call", 1));
     ops.push_back(CreateHWOp("jump", 1));
 }

References TTAMachine::Machine::addBus(), TTAMachine::Machine::addSocket(), and TTAMachine::Machine::setGlobalControl().

Here is the call graph for this function:

◆ ~BlocksGCU()

BlocksGCU::~BlocksGCU ( )

inline

Definition at line 61 of file BlocksGCU.hh.

                  {
         delete pc;
         delete val;
         delete ra;
         while (!ops.empty()) {
             delete ops.back();
             ops.pop_back();
         }
         delete raIn;
         delete raOut;
         delete valIn;
         delete pcIn;
         delete gcu;
     }

References gcu, ops, pc, pcIn, ra, raIn, raOut, val, and valIn.

Member Function Documentation

◆ BindPorts()

void BlocksGCU::BindPorts	(	TTAMachine::HWOperation *	hwOp,
		int	numOfOperands
	)

private

Bind the operation's operands to GCU ports.

Parameters

hwOp	A pointer to the hardware operation of which the operands need to be binded to GCU ports.
numOfOperands	The number of operands of the given hwOp.

Definition at line 127 of file BlocksGCU.cc.

                                                                    {
     if (numOfOperands < 2) {
         hwOp->bindPort(1, *pc);
     } else {
         hwOp->bindPort(2, *pc);  // Program counter is operand 2, therfore
                                  // port binding is switched.
         hwOp->bindPort(1, *val);
     }
 }

References TTAMachine::HWOperation::bindPort().

Here is the call graph for this function:

◆ ConfigurePipeline()

void BlocksGCU::ConfigurePipeline	(	TTAMachine::ExecutionPipeline *	pipeline,
		int	numOfOperands
	)

private

Configure the operation pipeline.

Parameters

pipeline	A pointer to the execution pipeline of the operation of which the pipeline needs to be configured.
numOfOperands	The number of operands of the given hwOp.

Definition at line 102 of file BlocksGCU.cc.

                                                               {
     if (numOfOperands == 1) {
         pipeline->addPortRead(1, 0, 1);
     } else if (numOfOperands == 2) {
         pipeline->addPortRead(1, 0, 1);
         pipeline->addPortRead(2, 0, 1);
     } else {
         // Currently no operation known that uses a different numbers of
         // operands.
         assert(
             false &&
             "Trying to add a GCU operation with a different number of "
             "operands than 1 or 2.");
     }
 }

References TTAMachine::ExecutionPipeline::addPortRead(), and assert.

Here is the call graph for this function:

◆ CreateHWOp()

HWOperation * BlocksGCU::CreateHWOp	(	const std::string &	name,
		int	numOfOperands
	)

private

Creates a hardware operation.

Parameters

name	The name of the hardware operation. This needs to exactly match the name in OSEd.
numOfOperands	The number of operands that this hardware operation requires.

Definition at line 146 of file BlocksGCU.cc.

                                                               {
     HWOperation* op = new HWOperation(name, *gcu);
     BindPorts(op, numOfOperands);
     ConfigurePipeline(op->pipeline(), numOfOperands);
     return op;
 }