BlocksTranslator Namespace Reference

Enumerations
enum	FU_TYPE {   FU_TYPE::ID, FU_TYPE::IU, FU_TYPE::ALU, FU_TYPE::RF,   FU_TYPE::MUL, FU_TYPE::LSU, FU_TYPE::ABU }

Functions
void	BuildTTAModel (BlocksModel &blocksModel, const std::string &outputName)
TTAMachine::Bus *	CreateConnection (TTAMachine::Machine &mach, TTAMachine::Socket *inputSocket, TTAMachine::Socket *outputSocket, BlocksGCU &gcu)
void	Deinitialize (TTAMachine::Machine &mach, std::list< BlocksALUPair * > aluList, std::list< BlocksLSUPair * > lsuList, std::list< BlocksRF * > rfList, std::list< BlocksIMM * > iuList, std::list< BlocksMULPair * > mulList)
void	ConnectInputs (TTAMachine::Machine &mach, BlocksGCU &gcu, std::list< BlocksALUPair * > aluList, std::list< BlocksLSUPair * > lsuList, std::list< BlocksRF * > rfList, std::list< BlocksMULPair * > mulList)
TTAMachine::Socket *	FindOutputSocket (TTAMachine::Machine::SocketNavigator nav, std::string source)

Enumeration Type Documentation

FU_TYPE

enum BlocksTranslator::FU_TYPE

strong

Enumerator
ID
IU
ALU
RF
MUL
LSU
ABU

Definition at line 44 of file BlocksModel.hh.

                   {
    ID,
    IU,  // Immediate unit
    ALU,
    RF,
    MUL,
    LSU,  // Load store unit
    ABU
};

Function Documentation

BuildTTAModel()

void BlocksTranslator::BuildTTAModel	(	BlocksModel &	blocksModel,
		const std::string &	outputName
	)

Build the TTA model (adf file) from the Blocks model.

Parameters

BlocksModel	The Blocks model created from the Blocks 'architecture.xml'.
outputName	The name of the output adf.

Definition at line 54 of file BlocksTranslator.cc.

                                                        {
    Machine ttaMach;
    ttaMach.setLittleEndian(true);
    // Create data and instruction adress spaces
    const int bitWidth = 8;
    const unsigned int minAddress = 0;
    // TODO(mm): Allow for different instr mem size than default
    const unsigned int maxAddressInstr = 2046;
    // TODO(mm): Allow for different data mem size than default
    const unsigned int maxAddressData = 32768;
    AddressSpace asData(
        "data", bitWidth, minAddress, maxAddressData, ttaMach);
    AddressSpace asInstr(
        "instructions", bitWidth, minAddress, maxAddressInstr, ttaMach);
 
    // Create a list for each functional unit type
    list<BlocksALUPair*> aluList;
    list<BlocksLSUPair*> lsuList;
    list<BlocksRF*> rfList;
    list<BlocksIMM*> iuList;
    list<BlocksMULPair*> mulList;
 
    // Default required unit
    InstructionTemplate limm("limm", ttaMach);
    BlocksGCU gcu(
        ttaMach, "abu",
        asInstr);  // Has to be created here so in IU slot can be added
 
    // Check which outputs of the FU are used, each output requires a seperate
    // TTA FU.
    for (auto& fu : blocksModel.mFunctionalUnitList) {
        for (auto& source : fu.src) {
            // Split the string into FU and port
            string sourcePort = source.substr(source.rfind(".") + 1);
            string sourceFu = source.substr(0, source.rfind("."));
            // Set the usesOutx to true
            for (auto& srcFu : blocksModel.mFunctionalUnitList) {
                if (srcFu.name == sourceFu) {
                    if (sourcePort == "0")
                        srcFu.usesOut0 = true;
                    else
                        srcFu.usesOut1 = true;
                }
            }
        }
    }
 
    // Create for each Blocks unit a TTA unit (except default GCU and IDs)
    for (auto& fu : blocksModel.mFunctionalUnitList) {
        switch (fu.type) {
            case FU_TYPE::ID:
                break;  // Instruction decoders are not taken into account.
            case FU_TYPE::LSU:
                lsuList.push_back(new BlocksLSUPair(
                    ttaMach, fu.name, fu.src, asData, fu.usesOut0,
                    fu.usesOut1));
                break;
            case FU_TYPE::ALU:
                aluList.push_back(new BlocksALUPair(
                    ttaMach, fu.name, fu.src, fu.usesOut0, fu.usesOut1));
                break;
            case FU_TYPE::RF:
                rfList.push_back(new BlocksRF(ttaMach, fu.name, fu.src));
                break;
            case FU_TYPE::IU:
                iuList.push_back(new BlocksIMM(ttaMach, fu.name, fu.src));
                if (iuList.size() == 1)
                    limm.addSlot("ra_out_to_ra_in", 32, *(iuList.back()->iu));
                break;
            case FU_TYPE::MUL:
                mulList.push_back(new BlocksMULPair(
                    ttaMach, fu.name, fu.src, fu.usesOut0, fu.usesOut1));
                break;
            case FU_TYPE::ABU:
                gcu.sources = fu.src;
                break;
            default:
                try {
                    throw "Illegal function unit type in Blocks.xml file, aborting translation. \n";
                } catch (const char* error) {
                    fprintf(stderr, "%s", error);
                    Deinitialize(
                        ttaMach, aluList, lsuList, rfList, iuList, mulList);
                    return;
                }
        }
    }
 
    ConnectInputs(ttaMach, gcu, aluList, lsuList, rfList, mulList);
    ttaMach.writeToADF(outputName);
    Deinitialize(ttaMach, aluList, lsuList, rfList, iuList, mulList);
}

References TTAMachine::InstructionTemplate::addSlot(), ConnectInputs(), Deinitialize(), IU, BlocksModel::mFunctionalUnitList, RF, TTAMachine::Machine::setLittleEndian(), BlocksGCU::sources, and TTAMachine::Machine::writeToADF().

Referenced by main().

Here is the call graph for this function:

ConnectInputs()

void BlocksTranslator::ConnectInputs	(	TTAMachine::Machine &	mach,
		BlocksGCU &	gcu,
		std::list< BlocksALUPair * >	aluList,
		std::list< BlocksLSUPair * >	lsuList,
		std::list< BlocksRF * >	rfList,
		std::list< BlocksMULPair * >	mulList
	)

Create all the connectivity in the TTA model.

Parameters

mach	The TTA machine where the connections need to be made.
gcu	A reference to the TTA GCU (ABU) model.
aluList	A list with all ALU pairs currently in the TTA model.
lsuList	A list with all LSU pairs currently in the TTA model.
rfList	A list with all RFs currently in the TTA model.
mulList	A list with all MUL pairs currently in the TTA model.

Definition at line 225 of file BlocksTranslator.cc.

                                                                {
    Machine::SocketNavigator nav = mach.socketNavigator();
    // Create ALU connections (all connections that are an input to the ALUs)
    for (auto& blocksAlu : aluList) {
        for (auto& source : blocksAlu->sources) {
            Socket* outputSocket = FindOutputSocket(nav, source);
            CreateConnection(
                mach, blocksAlu->in1sock.get(), outputSocket, gcu);
            CreateConnection(
                mach, blocksAlu->in2sock.get(), outputSocket, gcu);
        }
    }
 
    // Create LSU connections (all connections that are an input to the LSUs)
    for (auto& lsu : lsuList) {
        for (auto& source : lsu->sources) {
            Socket* outputSocket = FindOutputSocket(nav, source);
            CreateConnection(mach, lsu->in1sock.get(), outputSocket, gcu);
            CreateConnection(mach, lsu->in2sock.get(), outputSocket, gcu);
        }
    }
 
    // Create MUL connections (all connections that are an input to the MULs)
    for (auto& mul : mulList) {
        for (auto& source : mul->sources) {
            Socket* outputSocket = FindOutputSocket(nav, source);
            CreateConnection(mach, mul->in1sock.get(), outputSocket, gcu);
            CreateConnection(mach, mul->in2sock.get(), outputSocket, gcu);
        }
    }
 
    // Create RF connections (all connections that are an input to the RFs)
    for (auto& rf : rfList) {
        for (auto& source : rf->sources) {
            Socket* outputSocket = FindOutputSocket(nav, source);
            CreateConnection(mach, rf->in1sock, outputSocket, gcu);
        }
    }
 
    // IMM has no input socket so is skipped.
    // Create GCU connections
    for (auto& source : gcu.sources) {
        Socket* outputSocket = FindOutputSocket(nav, source);
        CreateConnection(mach, gcu.pcIn, outputSocket, gcu);
        CreateConnection(mach, gcu.valIn, outputSocket, gcu);
    }
}

References CreateConnection(), FindOutputSocket(), BlocksGCU::pcIn, TTAMachine::Machine::socketNavigator(), BlocksGCU::sources, and BlocksGCU::valIn.

Referenced by BuildTTAModel().

Here is the call graph for this function:

CreateConnection()

Bus * BlocksTranslator::CreateConnection	(	TTAMachine::Machine &	mach,
		TTAMachine::Socket *	inputSocket,
		TTAMachine::Socket *	outputSocket,
		BlocksGCU &	gcu
	)

Create a connection between two different sockets. Note: Input := Bus to port, output := Port to bus.

Parameters

mach	The TTA machine where the connection needs to be made.
inputSocket	A pointer to the TTA input socket that needs to be connected.
outputSocket	A pointer to the TTA output socket that needs to be connected.
gcu	A reference to the TTA GCU (ABU) model.

Definition at line 160 of file BlocksTranslator.cc.

                    {
    // TODO(mm): add exception catching where given "input" is not an input
    // port
    const int busWidth = 32;
    const int immWidth = 0;
    const string& to = inputSocket->name();
    const string& from = outputSocket->name();
    Machine::Extension busExt = Machine::Extension::ZERO;
    Machine::BusNavigator busNav = mach.busNavigator();
    const string newBusNum = to_string(busNav.count());
    Bus* ttaBus;
    // Verify if the socket is already attached to a bus (excluding
    // 'ra_out_to_ra_in')
    if (inputSocket->segmentCount() == 0) {
        ttaBus = new Bus("bus_" + newBusNum, busWidth, immWidth, busExt);
        mach.addBus(*ttaBus);
        new Segment("seg1", *ttaBus);
        if (inputSocket->name() == "ra_in" || inputSocket->name() == "pc") {
            gcu.pcIn->attachBus(*ttaBus);
            gcu.raIn->attachBus(*ttaBus);
        } else {
            inputSocket->attachBus(*ttaBus);
        }
    } else if (
        inputSocket->segmentCount() == 1 &&
        inputSocket->segment(0)->parentBus()->name() == "ra_out_to_ra_in") {
        ttaBus = new Bus("bus_" + newBusNum, busWidth, immWidth, busExt);
        mach.addBus(*ttaBus);
        new Segment("seg1", *ttaBus);
        if (inputSocket->name() == "ra_in" || inputSocket->name() == "pc") {
            gcu.pcIn->attachBus(*ttaBus);
            gcu.raIn->attachBus(*ttaBus);
        } else {
            inputSocket->attachBus(*ttaBus);
        }
    } else if (
        inputSocket->segmentCount() == 2 &&
        inputSocket->segment(0)->parentBus()->name() == "ra_out_to_ra_in") {
        Segment* segment1 = inputSocket->segment(1);
        ttaBus = segment1->parentBus();
    }
    // Not 'ra_out_to_ra_in' and segmentCount == 1
    else {
        Segment* segment1 = inputSocket->segment(0);
        ttaBus = segment1->parentBus();
    }
    // Attach busses to sockets
    outputSocket->attachBus(*ttaBus);
    outputSocket->setDirection(Socket::Direction::OUTPUT);
    return ttaBus;
}

References TTAMachine::Machine::addBus(), TTAMachine::Socket::attachBus(), TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Component::name(), TTAMachine::Segment::parentBus(), BlocksGCU::pcIn, BlocksGCU::raIn, TTAMachine::Socket::segment(), TTAMachine::Socket::segmentCount(), and TTAMachine::Socket::setDirection().

Referenced by ConnectInputs().

Here is the call graph for this function:

Deinitialize()

void BlocksTranslator::Deinitialize	(	TTAMachine::Machine &	mach,
		std::list< BlocksALUPair * >	aluList,
		std::list< BlocksLSUPair * >	lsuList,
		std::list< BlocksRF * >	rfList,
		std::list< BlocksIMM * >	iuList,
		std::list< BlocksMULPair * >	mulList
	)

Clean up the memory, deletes all FUs and busses.

Parameters

mach	The TTA machine where the connections need to be made.
aluList	A list with all ALU pairs currently in the TTA model.
lsuList	A list with all LSU pairs currently in the TTA model.
rfList	A list with all RFs currently in the TTA model.
mulList	A list with all MUL pairs currently in the TTA model.

Definition at line 304 of file BlocksTranslator.cc.

                                                                 {
    while (!aluList.empty()) {
        delete aluList.front();
        aluList.pop_front();
    }
    while (!lsuList.empty()) {
        delete lsuList.front();
        lsuList.pop_front();
    }
    while (!rfList.empty()) {
        delete rfList.front();
        rfList.pop_front();
    }
    while (!iuList.empty()) {
        delete iuList.front();
        iuList.pop_front();
    }
    while (!mulList.empty()) {
        delete mulList.front();
        mulList.pop_front();
    }
    // Delete busses
    Machine::BusNavigator busNav = mach.busNavigator();
    while (busNav.count() != 0) {
        Bus* toDelete = busNav.item(busNav.count() - 1);
        delete toDelete->segment(0);
        delete toDelete;
    }
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::item(), and TTAMachine::Bus::segment().

Referenced by BuildTTAModel().

Here is the call graph for this function:

FindOutputSocket()

Socket * BlocksTranslator::FindOutputSocket	(	TTAMachine::Machine::SocketNavigator	nav,
		std::string	source
	)

Find the output socket corresponding to a FU name.

Parameters

nav	An instance of a socketnavigator.
source	The source of which the handle to the output socket needs to be returned.

Definition at line 284 of file BlocksTranslator.cc.

                                               {
    // String manipulation to get the right format
    source.replace(source.rfind("."), 1, "_out");
    assert(
        nav.hasItem(source) &&
        "Cannot create connection, output socket not found!");
    return nav.item(source);
}

References assert, TTAMachine::Machine::Navigator< ComponentType >::hasItem(), and TTAMachine::Machine::Navigator< ComponentType >::item().

Referenced by ConnectInputs().

Here is the call graph for this function: