ProGe::PortFactory Class Reference

#include <NetlistFactories.hh>

Collaboration diagram for ProGe::PortFactory:

Public Member Functions
	PortFactory (const TTAMachine::Machine &machine, const IDF::MachineImplementation &impl)
virtual	~PortFactory ()
NetlistPort *	createPort (SignalType type, Direction direction=IN) const
NetlistPortGroup *	createPortGroup (SignalGroupType type) const

Static Public Member Functions
static NetlistPort *	create (SignalType type, Direction direction=IN)
static NetlistPortGroup *	create (SignalGroupType type)
static void	initializeContext (const TTAMachine::Machine &machine, const IDF::MachineImplementation &impl)
static PortFactory *	instance ()
static NetlistPort *	clockPort (Direction direction=IN)
static NetlistPort *	resetPort (Direction direction=IN)

Private Types
typedef std::map< SignalType, const NetlistPort * >	PortPrototypeContainer
typedef std::map< SignalGroupType, const NetlistPortGroup * >	PortGroupPrototypeContainer

Private Member Functions
	PortFactory ()
void	registerPort (SignalType, const NetlistPort *port)
void	registerPort (const NetlistPort *port)
void	registerPorts ()
void	registerPortGroup (SignalGroupType type, const NetlistPortGroup *portGroup)
void	registerPortGroup (const NetlistPortGroup *portGroup)
void	registerPortGroups ()

Private Attributes
PortPrototypeContainer	portPrototypes_
	The creation context.
PortGroupPrototypeContainer	portGroupPrototypes_
	Registered NetlistPortGroup prototypes.

Static Private Attributes
static PortFactory *	instance_ = NULL
	Singleton instance of the factory.
static const TTAMachine::Machine *	staticMachine_ = NULL
	The creation context for singleton instance.
static const IDF::MachineImplementation *	staticImplementation_ = NULL
	The creation context for singleton instance.

Detailed Description

Definition at line 55 of file NetlistFactories.hh.

Member Typedef Documentation

PortGroupPrototypeContainer

typedef std::map<SignalGroupType, const NetlistPortGroup*> ProGe::PortFactory::PortGroupPrototypeContainer

private

Definition at line 90 of file NetlistFactories.hh.

PortPrototypeContainer

typedef std::map<SignalType, const NetlistPort*> ProGe::PortFactory::PortPrototypeContainer

private

Definition at line 88 of file NetlistFactories.hh.

Constructor & Destructor Documentation

PortFactory() [1/2]

ProGe::PortFactory::PortFactory	(	const TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	impl
	)

Definition at line 53 of file NetlistFactories.cc.

{}

~PortFactory()

ProGe::PortFactory::~PortFactory ( )

virtual

Definition at line 60 of file NetlistFactories.cc.

                          {
    PortPrototypeContainer::iterator port_it = portPrototypes_.begin();
    while (port_it != portPrototypes_.end()) {
        delete port_it->second;
        port_it->second = NULL;
        port_it++;
    }
    PortGroupPrototypeContainer::iterator portGroup_it =
        portGroupPrototypes_.begin();
    while (portGroup_it != portGroupPrototypes_.end()) {
        delete portGroup_it->second;
        portGroup_it->second = NULL;
        portGroup_it++;
    }
}

References portGroupPrototypes_, and portPrototypes_.

PortFactory() [2/2]

ProGe::PortFactory::PortFactory ( )

private

Definition at line 48 of file NetlistFactories.cc.

{}

Referenced by instance().

Member Function Documentation

clockPort()

NetlistPort * ProGe::PortFactory::clockPort ( Direction  direction = IN )

static

Creates default clock port.

Definition at line 200 of file NetlistFactories.cc.

                                          {
    static const InBitPort clkPortPrototype("clk", Signal(SignalType::CLOCK));
    return clkPortPrototype.clone(direction != IN);
}

References ProGe::CLOCK, ProGe::NetlistPort::clone(), and ProGe::IN.

Referenced by ProGe::LoopBufferBlock::LoopBufferBlock(), ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock(), ProGe::SinglePortByteMaskSSRAMBlock::SinglePortByteMaskSSRAMBlock(), and ProGe::SinglePortSSRAMBlock::SinglePortSSRAMBlock().

Here is the call graph for this function:

create() [1/2]

NetlistPortGroup * ProGe::PortFactory::create ( SignalGroupType  type )

static

Definition at line 160 of file NetlistFactories.cc.

                                        {
    return instance()->createPortGroup(type);
}

References createPortGroup(), and instance().

Here is the call graph for this function:

create() [2/2]

NetlistPort * ProGe::PortFactory::create ( SignalType  type, Direction  direction = IN  )

static

Definition at line 147 of file NetlistFactories.cc.

                                                        {
    return instance()->createPort(type, direction);
}

References createPort(), and instance().

Here is the call graph for this function:

createPort()

NetlistPort * ProGe::PortFactory::createPort	(	SignalType	type,
		Direction	direction = IN
	)		const

Creates new NetlistPort for the given signal type.

Parameters

type	The signal type.

Returns

Pointer to newly created NetlistPort. Returns nullptr if there is no prototype for the given signal type.

Definition at line 134 of file NetlistFactories.cc.

                                                                  {
    if (portPrototypes_.count(type)) {
        NetlistPort* found = portPrototypes_.find(type)->second->clone();
        if (found->direction() != direction) {
            return NetlistTools::mirror(found);
        } else {
            return found;
        }
    }
    return NULL;
}

References ProGe::NetlistPort::clone(), ProGe::NetlistPort::direction(), ProGe::NetlistTools::mirror(), and portPrototypes_.

Referenced by create().

Here is the call graph for this function:

createPortGroup()

NetlistPortGroup * ProGe::PortFactory::createPortGroup

(

SignalGroupType

type

)

const

Definition at line 152 of file NetlistFactories.cc.

                                                       {
    if (portGroupPrototypes_.count(type)) {
        return portGroupPrototypes_.find(type)->second->clone();
    }
    return NULL;
}

References ProGe::NetlistPortGroup::clone(), and portGroupPrototypes_.

Referenced by create().

Here is the call graph for this function:

initializeContext()

void ProGe::PortFactory::initializeContext ( const TTAMachine::Machine &  machine, const IDF::MachineImplementation &  impl  )

static

Initializes factory context for the singleton factory. This function may be called only once.

Definition at line 169 of file NetlistFactories.cc.

                                          {
    assert(
        staticMachine_ == NULL && staticImplementation_ == NULL &&
        "Attempted to initialize twice.");
    staticMachine_ = &machine;
    staticImplementation_ = &impl;
}

References assert, machine, staticImplementation_, and staticMachine_.

instance()

PortFactory * ProGe::PortFactory::instance ( )

static

Global access to the factory as singleton. initializeContext() must be called once before this.

Definition at line 184 of file NetlistFactories.cc.

                      {
    if (instance_) {
        return instance_;
    } else {
        assert(staticMachine_ != NULL && staticImplementation_ != NULL);
        return (
            instance_ =
                new PortFactory(*staticMachine_, *staticImplementation_));
    }
}

References assert, instance_, PortFactory(), staticImplementation_, and staticMachine_.

Referenced by create(), and create().

Here is the call graph for this function:

registerPort() [1/2]

void ProGe::PortFactory::registerPort ( const NetlistPort *  port )

private

Definition at line 83 of file NetlistFactories.cc.

                                                 {
    assert(port->assignedSignal().type() != SignalType::UNDEFINED);
    registerPort(port->assignedSignal().type(), port);
}

References assert, ProGe::NetlistPort::assignedSignal(), registerPort(), ProGe::Signal::type(), and ProGe::UNDEFINED.

Here is the call graph for this function:

registerPort() [2/2]

void ProGe::PortFactory::registerPort ( SignalType  type, const NetlistPort *  port  )

private

Definition at line 77 of file NetlistFactories.cc.

                                                                  {
    assert(!AssocTools::containsKey(portPrototypes_, type));
    portPrototypes_.insert(std::make_pair(type, port));
}

References assert, AssocTools::containsKey(), and portPrototypes_.

Referenced by registerPort(), and registerPorts().

Here is the call graph for this function:

registerPortGroup() [1/2]

void ProGe::PortFactory::registerPortGroup ( const NetlistPortGroup *  portGroup )

private

Definition at line 103 of file NetlistFactories.cc.

                                                                {
    assert(
        portGroup->assignedSignalGroup().type() !=
        SignalGroupType::UNDEFINED);
 
    registerPortGroup(portGroup->assignedSignalGroup().type(), portGroup);
}

References assert, ProGe::NetlistPortGroup::assignedSignalGroup(), registerPortGroup(), ProGe::SignalGroup::type(), and ProGe::UNDEFINED.

Here is the call graph for this function:

registerPortGroup() [2/2]

void ProGe::PortFactory::registerPortGroup ( SignalGroupType  type, const NetlistPortGroup *  portGroup  )

private

Definition at line 96 of file NetlistFactories.cc.

                                                             {
    assert(!AssocTools::containsKey(portGroupPrototypes_, type));
    portGroupPrototypes_.insert(std::make_pair(type, portGroup));
}

References assert, AssocTools::containsKey(), and portGroupPrototypes_.

Referenced by registerPortGroup(), and registerPortGroups().

Here is the call graph for this function:

registerPortGroups()

void ProGe::PortFactory::registerPortGroups ( )

private

Definition at line 112 of file NetlistFactories.cc.

                                {
    registerPortGroup(new NetlistPortGroup(
        SignalGroup(SignalGroupType::INSTRUCTION_LINE),
        new OutBitPort(
            "imem_en_x", Signal(SignalType::READ_REQUEST, ActiveState::LOW)),
        new OutPort(
            "imem_addr", "IMEMADDRWIDTH", BIT_VECTOR,
            Signal(SignalType::ADDRESS)),
        new InPort(
            "imem_data", "IMEMWIDTHINMAUS*IMEMMAUWIDTH", BIT_VECTOR,
            Signal(SignalType::FETCHBLOCK)),
        new InBitPort("busy", Signal(SignalType::STALL))));
}

References ProGe::ADDRESS, ProGe::BIT_VECTOR, ProGe::FETCHBLOCK, ProGe::INSTRUCTION_LINE, ProGe::LOW, ProGe::READ_REQUEST, registerPortGroup(), and ProGe::STALL.

Here is the call graph for this function:

registerPorts()

void ProGe::PortFactory::registerPorts ( )

private

Definition at line 89 of file NetlistFactories.cc.

                           {
    registerPort(new InBitPort("clk", Signal(SignalType::CLOCK)));
    registerPort(
        new InBitPort("rstx", Signal(SignalType::RESET, ActiveState::LOW)));
}

References ProGe::CLOCK, ProGe::LOW, registerPort(), and ProGe::RESET.

Here is the call graph for this function:

resetPort()

NetlistPort * ProGe::PortFactory::resetPort ( Direction  direction = IN )

static

Creates default active-low reset port.

Definition at line 209 of file NetlistFactories.cc.

                                          {
    static const InBitPort rstxPortPrototype(
        "rstx", Signal(SignalType::RESET, ActiveState::LOW));
    return rstxPortPrototype.clone(direction != IN);
}

References ProGe::NetlistPort::clone(), ProGe::IN, ProGe::LOW, and ProGe::RESET.

Referenced by ProGe::LoopBufferBlock::LoopBufferBlock(), and ProGe::ProcessorWrapperBlock::ProcessorWrapperBlock().

Here is the call graph for this function:

Member Data Documentation

instance_

PortFactory * ProGe::PortFactory::instance_ = NULL

staticprivate

Singleton instance of the factory.

Definition at line 102 of file NetlistFactories.hh.

Referenced by instance().

portGroupPrototypes_

PortGroupPrototypeContainer ProGe::PortFactory::portGroupPrototypes_

private

Registered NetlistPortGroup prototypes.

Definition at line 99 of file NetlistFactories.hh.

Referenced by createPortGroup(), registerPortGroup(), and ~PortFactory().

portPrototypes_

PortPrototypeContainer ProGe::PortFactory::portPrototypes_

private

The creation context.

The creation context. Registered NetlistPort prototypes.

Definition at line 97 of file NetlistFactories.hh.

Referenced by createPort(), registerPort(), and ~PortFactory().

staticImplementation_

const IDF::MachineImplementation * ProGe::PortFactory::staticImplementation_ = NULL

staticprivate

The creation context for singleton instance.

Definition at line 106 of file NetlistFactories.hh.

Referenced by initializeContext(), and instance().

staticMachine_

const TTAMachine::Machine * ProGe::PortFactory::staticMachine_ = NULL

staticprivate

The creation context for singleton instance.

Definition at line 104 of file NetlistFactories.hh.

Referenced by initializeContext(), and instance().

---

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

• NetlistFactories.hh
• NetlistFactories.cc