#include <MachineAnalysis.hh>

Collaboration diagram for MachineAnalysis:

Public Member Functions
	MachineAnalysis (const TTAMachine::Machine &machine)

float	connectivity () const

float	bypassability () const

float	averageILP () const

float	busILP () const

float	fuILP () const

float	rfILP () const

float	bypassedRfILP () const

float	guardability () const

Private Attributes
float	connectivity_

float	busILP_

float	fuILP_

float	rfILP_

float	bypassedRfILP_

float	bypassability_

float	guardability_

float	averageILP_

Detailed Description

Definition at line 40 of file MachineAnalysis.hh.

Constructor & Destructor Documentation

◆ MachineAnalysis()

MachineAnalysis::MachineAnalysis ( const TTAMachine::Machine & machine )

Constructor.

Parameters

machine to analyse.

Definition at line 46 of file MachineAnalysis.cc.

                                                                 {
 
    // do heurictics for FU's
 
    TTAMachine::Machine::FunctionUnitNavigator fuNav = 
        machine.functionUnitNavigator();
 
    // todo: better heuristics here, based on available operations etc.
    fuILP_ = fuNav.count() * 0.55;
 
    // Connectivity heuristics
 
    int fuPortConnecteds = 0;
    int fuPortUnconnecteds = 0;
 
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit& fu1 = *fuNav.item(i);
        for (int j = 0; j < fu1.portCount(); j++ ) {
            TTAMachine::Port& port1 = *fu1.port(j);
            if (port1.inputSocket() != NULL) {
                for (int k = 0; k < fuNav.count(); k++) {
                    TTAMachine::FunctionUnit& fu2 = *fuNav.item(k);
                    for (int l = 0; l < fu2.portCount(); l++ ) {
                        TTAMachine::Port& port2 = *fu2.port(l);
                        if (port2.outputSocket() != NULL) {
                            if (MachineConnectivityCheck::isConnected(
                                    port2,port1)) {
                                fuPortConnecteds++;
                            } else {
                                fuPortUnconnecteds++;
                            }
                        }
                    }
                }
            }
        }
    }
        
    bypassability_ = fuPortConnecteds/
        float(fuPortConnecteds+fuPortUnconnecteds);
 
    TTAMachine::Machine::RegisterFileNavigator regNav =
        machine.registerFileNavigator();
    int rfCount = regNav.count();
 
    TTAMachine::Machine::BusNavigator busNav =
        machine.busNavigator();
 
    int rfFuConnecteds = 0;
    int rfFuUnconnecteds = 0;
 
    for (int i = 0; i < fuNav.count(); i++) {
        TTAMachine::FunctionUnit& fu1 = *fuNav.item(i);
        for (int j = 0; j < fu1.portCount(); j++ ) {
            TTAMachine::Port& port = *fu1.port(j);
            if (port.inputSocket() != NULL) {
                for (int i = 0; i < rfCount; i++) {
                    TTAMachine::RegisterFile& rf = *regNav.item(i);
                    if (MachineConnectivityCheck::isConnected(rf, port)) {
                        rfFuConnecteds++;
                    } else {
                        rfFuUnconnecteds++;
                    }
                }
            }
 
            if (port.outputSocket() != NULL) {
                for (int i = 0; i < rfCount; i++) {
                    TTAMachine::RegisterFile& rf = *regNav.item(i);
                    if (MachineConnectivityCheck::isConnected(port,rf)) {
                        rfFuConnecteds++;
                    } else {
                        rfFuUnconnecteds++;
                    }
                }
            }
        }
    }
 
    // do heuristics for RF's
    
    int rfWritePorts = 0;
    int rfReadPorts = 0;
    for (int i = 0; i < rfCount; i++) {
        TTAMachine::RegisterFile& rf = *regNav.item(i);
        for (int j = 0; j < rf.portCount(); j++) {
            const TTAMachine::Port& port = *rf.port(j);
            if (port.outputSocket() != NULL) {
                rfReadPorts++;
            }
            if (port.inputSocket() != NULL) {
                rfWritePorts++;
            }
        }
    }
    
    // rfILP comes from all RF's with 
    float avgRfWrites = float(rfWritePorts)/pow(rfCount,0.5);
    float avgRfReads = float(rfReadPorts)/pow(rfCount,0.5);
    float bypassedRfReadILP = avgRfReads/(1.17-(0.56*bypassability_));
    float bypassedRfWriteILP = avgRfWrites/(0.83-(0.415*bypassability_));
    float rfReadILP = avgRfReads/1.17;
    float rfWriteILP = avgRfWrites/0.83;
 
    // todo: fuzzier heuristic
    rfILP_ = std::min(rfReadILP, rfWriteILP);
    bypassedRfILP_ = std::min(bypassedRfReadILP, bypassedRfWriteILP);
 
    connectivity_ = rfFuConnecteds/
        float(rfFuConnecteds+rfFuUnconnecteds);
    float transfers = connectivity_* busNav.count();
    
    busILP_ = transfers / (2.5-(0.415*bypassability_));
 
    // take the final value by inverse of pythagoral of inverses
    averageILP_ = pow((pow(busILP_,-2)+
                       pow(bypassedRfILP_,-2)+
                       pow(fuILP_,-2)), -0.5);
 
    // then calculate guardability.
 
    float guardedBuses = 0;
    for (int i = 0; i < busNav.count(); i++) {
        TTAMachine::Bus& bus = *busNav.item(i);
        if (bus.guardCount() > 0) {
            guardedBuses++;
        }
    }
    guardability_ = busNav.count() / guardedBuses;
 
#ifdef DEBUG_MACHINE_ANALYSIS
    std::cout << "Machine analysis done.." << std::endl;
    std::cout << "\tbypassability: " << bypassability_ << std::endl;
    std::cout << "\tconnectivity: " << connectivity_ << std::endl;
    std::cout << "\tguardability: " << guardability_ << std::endl;
    std::cout << "\tRF ilp: " << rfILP_ << std::endl;
    std::cout << "\t\tread ilp: " << rfReadILP << std::endl;
    std::cout << "\t\twrite ilp: " << rfWriteILP << std::endl;
    std::cout << "\tbypassd rf ilp: " << bypassedRfILP_ << std::endl;
    std::cout << "\tbus ilp: " << busILP_ << std::endl;
    std::cout << "\tfu ilp: " << fuILP_ << std::endl;
    std::cout << "total ilp: " << averageILP_ << std::endl;
#endif
 
}