inet::GateScheduleConfiguratorBase Class Reference

#include <GateScheduleConfiguratorBase.h>

Inheritance diagram for inet::GateScheduleConfiguratorBase:

Classes
class	Input
class	Output

Public Member Functions
virtual	~GateScheduleConfiguratorBase ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	handleParameterChange (const char *name) override
virtual void	handleMessage (cMessage *msg) override
virtual void	clearConfiguration ()
virtual void	computeConfiguration ()
virtual Input *	createGateSchedulingInput () const
virtual void	addDevices (Input &input) const
virtual void	addSwitches (Input &input) const
virtual void	addPorts (Input &input) const
virtual void	addFlows (Input &input) const
virtual void	configureGateScheduling ()
virtual void	configureGateScheduling (cModule *networkNode, cModule *gate, Interface *interface)
virtual void	configureApplicationOffsets ()
virtual Output *	computeGateScheduling (const Input &input) const =0
Protected Member Functions inherited from inet::NetworkConfiguratorBase
virtual	~NetworkConfiguratorBase ()
virtual int	numInitStages () const override
virtual void	extractTopology (Topology &topology)
	Extracts network topology by walking through the module hierarchy. More...
virtual std::vector< Node * >	computeShortestNodePath (Node *source, Node *destination) const
virtual std::vector< Link * >	computeShortestLinkPath (Node *source, Node *destination) const
virtual bool	isBridgeNode (Node *node) const
virtual Link *	findLinkIn (const Node *node, const char *neighbor) const
virtual Link *	findLinkOut (const Node *node, const char *neighbor) const
virtual Link *	findLinkOut (const Node *node, const Node *neighbor) const
virtual Link *	findLinkOut (const Interface *interface) const
virtual Topology::Link *	findLinkOut (const Node *node, int gateId) const
virtual Interface *	findInterface (const Node *node, NetworkInterface *networkInterface) const

Protected Attributes
simtime_t	gateCycleDuration
cValueArray *	configuration = nullptr
Input *	gateSchedulingInput = nullptr
Output *	gateSchedulingOutput = nullptr
Protected Attributes inherited from inet::NetworkConfiguratorBase
Topology *	topology = nullptr

Constructor & Destructor Documentation

~GateScheduleConfiguratorBase()

virtual inet::GateScheduleConfiguratorBase::~GateScheduleConfiguratorBase ( )

inlinevirtual

{ clearConfiguration(); }

Member Function Documentation

addDevices()

void inet::GateScheduleConfiguratorBase::addDevices ( Input &  input ) const

protectedvirtual

{
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        if (!isBridgeNode(node)) {
            auto device = new Input::Device();
            device->module = node->module;
            input.devices.push_back(device);
            input.networkNodes.push_back(device);
        }
    }
}

Referenced by createGateSchedulingInput().

addFlows()

void inet::GateScheduleConfiguratorBase::addFlows ( Input &  input ) const

protectedvirtual

{
    int flowIndex = 0;
    EV_DEBUG << "Computing flows from configuration" << EV_FIELD(configuration) << EV_ENDL;
    for (int k = 0; k < configuration->size(); k++) {
        auto entry = check_and_cast<cValueMap *>(configuration->get(k).objectValue());
        for (int i = 0; i < topology->getNumNodes(); i++) {
            auto sourceNode = (Node *)topology->getNode(i);
            cModule *source = sourceNode->module;
            for (int j = 0; j < topology->getNumNodes(); j++) {
                auto destinationNode = (Node *)topology->getNode(j);
                cModule *destination = destinationNode->module;
                PatternMatcher sourceMatcher(entry->get("source").stringValue(), true, false, false);
                PatternMatcher destinationMatcher(entry->get("destination").stringValue(), true, false, false);
                if (sourceMatcher.matches(sourceNode->module->getFullPath().c_str()) &&
                    destinationMatcher.matches(destinationNode->module->getFullPath().c_str()))
                {
                    int pcp = entry->get("pcp").intValue();
                    int gateIndex = entry->get("gateIndex").intValue();
                    b packetLength = b(entry->get("packetLength").doubleValueInUnit("b"));
                    simtime_t packetInterval = entry->get("packetInterval").doubleValueInUnit("s");
                    simtime_t maxLatency = entry->containsKey("maxLatency") ? entry->get("maxLatency").doubleValueInUnit("s") : -1;
                    simtime_t maxJitter = entry->containsKey("maxJitter") ? entry->get("maxJitter").doubleValueInUnit("s") : 0;
                    bps datarate = packetLength / s(packetInterval.dbl());
                    auto startDevice = input.getDevice(source);
                    auto endDevice = input.getDevice(destination);
                    auto startApplication = new Input::Application();
                    auto startApplicationModule = startDevice->module->getModuleByPath((std::string(".") + std::string(entry->get("application").stringValue())).c_str());
                    if (startApplicationModule == nullptr)
                        throw cRuntimeError("Cannot find flow start application, path = %s", entry->get("application").stringValue());
                    startApplication->module = startApplicationModule;
                    startApplication->device = startDevice;
                    startApplication->pcp = pcp;
                    startApplication->packetLength = packetLength;
                    startApplication->packetInterval = packetInterval;
                    startApplication->maxLatency = maxLatency;
                    startApplication->maxJitter = maxJitter;
                    input.applications.push_back(startApplication);
                    EV_DEBUG << "Adding flow from configuration" << EV_FIELD(source) << EV_FIELD(destination) << EV_FIELD(pcp) << EV_FIELD(packetLength) << EV_FIELD(packetInterval, packetInterval.ustr()) << EV_FIELD(datarate) << EV_FIELD(maxLatency, maxLatency.ustr()) << EV_FIELD(maxJitter, maxJitter.ustr()) << EV_ENDL;
                    auto flow = new Input::Flow();
                    flow->name = entry->containsKey("name") ? entry->get("name").stringValue() : (std::string("flow") + std::to_string(flowIndex++)).c_str();
                    flow->gateIndex = gateIndex;
                    flow->startApplication = startApplication;
                    flow->endDevice = endDevice;
                    cValueArray *pathFragments;
                    if (entry->containsKey("pathFragments"))
                        pathFragments = check_and_cast<cValueArray *>(entry->get("pathFragments").objectValue());
                    else {
                        auto pathFragment = new cValueArray();
                        for (auto node : computeShortestNodePath(sourceNode, destinationNode))
                            pathFragment->add(node->module->getFullName());
                        pathFragments = new cValueArray();
                        pathFragments->add(pathFragment);
                    }
                    for (int l = 0; l < pathFragments->size(); l++) {
                        auto path = new Input::PathFragment();
                        auto pathFragment = check_and_cast<cValueArray *>(pathFragments->get(l).objectValue());
                        for (int m = 0; m < pathFragment->size(); m++) {
                            for (auto networkNode : input.networkNodes) {
                                auto name = pathFragment->get(m).stdstringValue();
                                int index = name.find('.');
                                auto nodeName = index != std::string::npos ? name.substr(0, index) : name;
                                auto interfaceName = index != std::string::npos ? name.substr(index + 1) : "";
                                if (networkNode->module->getFullName() == nodeName) {
                                    if (m != pathFragment->size() - 1) {
                                        auto startNode = networkNode;
                                        auto endNodeName = pathFragment->get(m + 1).stdstringValue();
                                        int index = endNodeName.find('.');
                                        endNodeName = index != std::string::npos ? endNodeName.substr(0, index) : endNodeName;
                                        auto outputPort = *std::find_if(startNode->ports.begin(), startNode->ports.end(), [&] (const auto& port) {
                                            return port->endNode->module->getFullName() == endNodeName && (interfaceName == "" || interfaceName == check_and_cast<NetworkInterface *>(port->module)->getInterfaceName());
                                        });
                                        path->outputPorts.push_back(outputPort);
                                        path->inputPorts.push_back(outputPort->otherPort);
                                    }
                                    path->networkNodes.push_back(networkNode);
                                    break;
                                }
                            }
                        }
                        flow->pathFragments.push_back(path);
                    }
                    if (!entry->containsKey("pathFragments"))
                        delete pathFragments;
                    input.flows.push_back(flow);
                }
            }
        }
    }
    std::sort(input.flows.begin(), input.flows.end(), [] (const Input::Flow *r1, const Input::Flow *r2) {
        return r1->startApplication->pcp > r2->startApplication->pcp;
    });
}

Referenced by createGateSchedulingInput().

addPorts()

void inet::GateScheduleConfiguratorBase::addPorts ( Input &  input ) const

protectedvirtual

{
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        auto networkNode = input.getNetworkNode(node->module);
        for (auto interface : node->interfaces) {
            auto networkInterface = interface->networkInterface;
            if (!networkInterface->isLoopback()) {
                auto subqueue = networkInterface->findModuleByPath(".macLayer.queue.queue[0]");
                auto port = new Input::Port();
                port->numGates = subqueue != nullptr ? subqueue->getVectorSize() : -1;
                port->module = interface->networkInterface;
                port->datarate = bps(interface->networkInterface->getDatarate());
                port->propagationTime = check_and_cast<cDatarateChannel *>(interface->networkInterface->getTxTransmissionChannel())->getDelay();
                port->maxPacketLength = B(interface->networkInterface->getMtu());
                port->guardBand = s(port->maxPacketLength / port->datarate).get();
                port->maxCycleTime = gateCycleDuration;
                port->maxSlotDuration = gateCycleDuration;
                port->startNode = networkNode;
                networkNode->ports.push_back(port);
                input.ports.push_back(port);
            }
        }
    }
    for (auto networkNode : input.networkNodes) {
        auto node = check_and_cast<Node *>(topology->getNodeFor(networkNode->module));
        for (auto port : networkNode->ports) {
            auto networkInterface = check_and_cast<NetworkInterface *>(port->module);
            auto link = findLinkOut(findInterface(node, networkInterface));
            auto linkOut = findLinkOut(node, networkInterface->getNodeOutputGateId());
            auto remoteNode = check_and_cast<Node *>(linkOut->getLinkOutRemoteNode());
            port->endNode = *std::find_if(input.networkNodes.begin(), input.networkNodes.end(), [&] (const auto& networkNode) {
                return networkNode->module == remoteNode->module;
            });
            port->otherPort = *std::find_if(input.ports.begin(), input.ports.end(), [&] (const auto& otherPort) {
                return otherPort->module == link->destinationInterface->networkInterface;
            });
            ASSERT(port->endNode);
            ASSERT(port->otherPort);
        }
    }
}

Referenced by createGateSchedulingInput().

addSwitches()

void inet::GateScheduleConfiguratorBase::addSwitches ( Input &  input ) const

protectedvirtual

{
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        if (isBridgeNode(node)) {
            auto switch_ = new Input::Switch();
            switch_->module = node->module;
            input.switches.push_back(switch_);
            input.networkNodes.push_back(switch_);
        }
    }
}

Referenced by createGateSchedulingInput().

clearConfiguration()

void inet::GateScheduleConfiguratorBase::clearConfiguration ( )

protectedvirtual

{
    if (topology != nullptr)
        topology->clear();
    delete gateSchedulingInput;
    gateSchedulingInput = nullptr;
    delete gateSchedulingOutput;
    gateSchedulingOutput = nullptr;
}

Referenced by handleParameterChange().

computeConfiguration()

void inet::GateScheduleConfiguratorBase::computeConfiguration ( )

protectedvirtual

{
    long startTime = clock();
    delete topology;
    topology = new Topology();
    TIME(extractTopology(*topology));
    TIME(gateSchedulingInput = createGateSchedulingInput());
    TIME(gateSchedulingOutput = computeGateScheduling(*gateSchedulingInput));
    printElapsedTime("computeConfiguration", startTime);
}

Referenced by handleParameterChange(), and initialize().

computeGateScheduling()

virtual Output* inet::GateScheduleConfiguratorBase::computeGateScheduling ( const Input &  input ) const

protectedpure virtual

Implemented in inet::Z3GateScheduleConfigurator, inet::EagerGateScheduleConfigurator, inet::TSNschedGateScheduleConfigurator, and inet::AlwaysOpenGateScheduleConfigurator.

Referenced by computeConfiguration().

configureApplicationOffsets()

void inet::GateScheduleConfiguratorBase::configureApplicationOffsets ( )

protectedvirtual

{
    for (auto& it : gateSchedulingOutput->applicationStartTimes) {
        auto startOffset = it.second;
        auto applicationModule = it.first->module;
        EV_DEBUG << "Setting initial packet production offset for application source" << EV_FIELD(applicationModule) << EV_FIELD(startOffset) << EV_ENDL;
        auto sourceModule = applicationModule->getSubmodule("source");
        sourceModule->par("initialProductionOffset") = startOffset.dbl();
    }
}

Referenced by handleParameterChange(), and initialize().

configureGateScheduling() [1/2]

void inet::GateScheduleConfiguratorBase::configureGateScheduling ( )

protectedvirtual

{
    for (int i = 0; i < topology->getNumNodes(); i++) {
        auto node = (Node *)topology->getNode(i);
        auto networkNode = node->module;
        for (auto interface : node->interfaces) {
            auto queue = interface->networkInterface->findModuleByPath(".macLayer.queue");
            if (queue != nullptr) {
                for (cModule::SubmoduleIterator it(queue); !it.end(); ++it) {
                    cModule *gate = *it;
                    if (dynamic_cast<queueing::PeriodicGate *>(gate) != nullptr)
                        configureGateScheduling(networkNode, gate, interface);
                }
            }
        }
    }
}

Referenced by handleParameterChange(), and initialize().

configureGateScheduling() [2/2]

void inet::GateScheduleConfiguratorBase::configureGateScheduling ( cModule *  networkNode, cModule *  gate, Interface *  interface  )

protectedvirtual

{
    auto networkInterface = interface->networkInterface;
    bool initiallyOpen = false;
    simtime_t offset = 0;
    simtime_t slotEnd = 0;
    int gateIndex = gate->getIndex();
    auto port = gateSchedulingInput->getPort(networkInterface);
    auto it = gateSchedulingOutput->gateSchedules.find(port);
    if (it == gateSchedulingOutput->gateSchedules.end())
        throw cRuntimeError("Cannot find schedule for interface, interface = %s", networkInterface->getInterfaceFullPath().c_str());
    auto& schedules = it->second;
    if (gateIndex >= schedules.size())
        throw cRuntimeError("Cannot find schedule for traffic class, interface = %s, gate index = %d", port->module->getFullPath().c_str(), gateIndex);
    auto schedule = schedules[gateIndex];
    cValueArray *durations = new cValueArray();
    for (auto& slot : schedule->slots) {
        simtime_t slotStart = slot.start;
        simtime_t slotDuration = slot.duration;
        if (slotStart < 0 || slotStart + slotDuration > gateCycleDuration)
            throw cRuntimeError("Invalid slot start and/or duration");
        if (slotStart == 0)
            initiallyOpen = true;
        else {
            simtime_t duration = slotStart - slotEnd;
            ASSERT(duration >= 0);
            durations->add(cValue(duration.dbl(), "s"));
        }
        durations->add(cValue(slotDuration.dbl(), "s"));
        slotEnd = slotStart + slotDuration;
    }
    simtime_t remainingDuration = schedule->cycleDuration - slotEnd;
    if (slotEnd != 0) {
        if (remainingDuration != 0)
            durations->add(cValue(remainingDuration.dbl(), "s"));
        if (durations->size() % 2 != 0)
            durations->add(cValue(0, "s"));
    }
    EV_DEBUG << "Configuring gate scheduling parameters" << EV_FIELD(networkNode) << EV_FIELD(networkInterface) << EV_FIELD(gate) << EV_FIELD(initiallyOpen) << EV_FIELD(offset) << EV_FIELD(durations) << EV_ENDL;
    gate->par("initiallyOpen") = initiallyOpen;
    gate->par("offset") = offset.dbl();
    cPar& durationsPar = gate->par("durations");
    durationsPar.copyIfShared();
    durationsPar.setObjectValue(durations);
}

createGateSchedulingInput()

GateScheduleConfiguratorBase::Input * inet::GateScheduleConfiguratorBase::createGateSchedulingInput ( ) const

protectedvirtual

{
    auto input = new Input();
    addDevices(*input);
    addSwitches(*input);
    addPorts(*input);
    addFlows(*input);
    return input;
}

Referenced by computeConfiguration().

handleMessage()

virtual void inet::GateScheduleConfiguratorBase::handleMessage ( cMessage *  msg )

inlineoverrideprotectedvirtual

Reimplemented from inet::NetworkConfiguratorBase.

{ throw cRuntimeError("this module doesn't handle messages, it runs only in initialize()"); }

handleParameterChange()

void inet::GateScheduleConfiguratorBase::handleParameterChange ( const char *  name )

overrideprotectedvirtual

{
    if (name != nullptr) {
        if (!strcmp(name, "configuration")) {
            configuration = check_and_cast<cValueArray *>(par("configuration").objectValue());
            clearConfiguration();
            computeConfiguration();
            configureGateScheduling();
            configureApplicationOffsets();
        }
    }
}

initialize()

void inet::GateScheduleConfiguratorBase::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented in inet::Z3GateScheduleConfigurator.

{
    if (stage == INITSTAGE_LOCAL) {
        gateCycleDuration = par("gateCycleDuration");
        configuration = check_and_cast<cValueArray *>(par("configuration").objectValue());
    }
    if (stage == INITSTAGE_QUEUEING) {
        computeConfiguration();
        configureGateScheduling();
        configureApplicationOffsets();
    }
}

Referenced by inet::Z3GateScheduleConfigurator::initialize().

Member Data Documentation

configuration

cValueArray* inet::GateScheduleConfiguratorBase::configuration = nullptr

protected

Referenced by addFlows(), handleParameterChange(), and initialize().

gateCycleDuration

simtime_t inet::GateScheduleConfiguratorBase::gateCycleDuration

protected

Referenced by addPorts(), inet::AlwaysOpenGateScheduleConfigurator::computeGateScheduling(), inet::EagerGateScheduleConfigurator::computeGateScheduling(), inet::Z3GateScheduleConfigurator::computeGateScheduling(), inet::EagerGateScheduleConfigurator::computeStreamStartOffset(), configureGateScheduling(), inet::TSNschedGateScheduleConfigurator::convertInputToJson(), and initialize().

gateSchedulingInput

Input* inet::GateScheduleConfiguratorBase::gateSchedulingInput = nullptr

protected

Referenced by clearConfiguration(), computeConfiguration(), and configureGateScheduling().

gateSchedulingOutput

Output* inet::GateScheduleConfiguratorBase::gateSchedulingOutput = nullptr

protected

Referenced by clearConfiguration(), computeConfiguration(), configureApplicationOffsets(), and configureGateScheduling().

---

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

• GateScheduleConfiguratorBase.h
• GateScheduleConfiguratorBase.cc