diff options
Diffstat (limited to 'src/mem/ruby')
37 files changed, 4846 insertions, 0 deletions
diff --git a/src/mem/ruby/network/BasicRouter.py b/src/mem/ruby/network/BasicRouter.py index 28fcdc47e..68a7b1d8b 100644 --- a/src/mem/ruby/network/BasicRouter.py +++ b/src/mem/ruby/network/BasicRouter.py @@ -34,4 +34,6 @@ class BasicRouter(ClockedObject): type = 'BasicRouter' cxx_header = "mem/ruby/network/BasicRouter.hh" router_id = Param.Int("ID in relation to other routers") + + # only used by garnet latency = Param.Cycles(1, "number of cycles inside router") diff --git a/src/mem/ruby/network/garnet2.0/CommonTypes.hh b/src/mem/ruby/network/garnet2.0/CommonTypes.hh new file mode 100644 index 000000000..63fc464a6 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/CommonTypes.hh @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_COMMONTYPES_HH__ +#define __MEM_RUBY_NETWORK_GARNET_COMMONTYPES_HH__ + +#include "mem/ruby/common/NetDest.hh" + +// All common enums and typedefs go here + +enum flit_type {HEAD_, BODY_, TAIL_, HEAD_TAIL_, NUM_FLIT_TYPE_}; +enum VC_state_type {IDLE_, VC_AB_, ACTIVE_, NUM_VC_STATE_TYPE_}; +enum VNET_type {CTRL_VNET_, DATA_VNET_, NULL_VNET_, NUM_VNET_TYPE_}; +enum flit_stage {I_, VA_, SA_, ST_, LT_, NUM_FLIT_STAGE_}; +enum link_type { EXT_IN_, EXT_OUT_, INT_, NUM_LINK_TYPES_ }; +enum RoutingAlgorithm { TABLE_ = 0, XY_ = 1, CUSTOM_ = 2, + NUM_ROUTING_ALGORITHM_}; + +struct RouteInfo +{ + // destination format for table-based routing + int vnet; + NetDest net_dest; + + // src and dest format for topology-specific routing + int src_ni; + int src_router; + int dest_ni; + int dest_router; + int hops_traversed; +}; + +#define INFINITE_ 10000 + +#endif // __MEM_RUBY_NETWORK_GARNET_COMMONTYPES_HH__ diff --git a/src/mem/ruby/network/garnet2.0/Credit.cc b/src/mem/ruby/network/garnet2.0/Credit.cc new file mode 100644 index 000000000..6bc7ca209 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/Credit.cc @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/Credit.hh" + +// Credit Signal for buffers inside VC +// Carries m_vc (inherits from flit.hh) +// and m_is_free_signal (whether VC is free or not) + +Credit::Credit(int vc, bool is_free_signal, Cycles curTime) +{ + m_id = 0; + m_vc = vc; + m_is_free_signal = is_free_signal; + m_time = curTime; +} diff --git a/src/mem/ruby/network/garnet2.0/Credit.hh b/src/mem/ruby/network/garnet2.0/Credit.hh new file mode 100644 index 000000000..c2984e9ee --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/Credit.hh @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_CREDIT_HH__ +#define __MEM_RUBY_NETWORK_GARNET_CREDIT_HH__ + +#include <cassert> +#include <iostream> + +#include "base/types.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/flit.hh" + +// Credit Signal for buffers inside VC +// Carries m_vc (inherits from flit.hh) +// and m_is_free_signal (whether VC is free or not) + +class Credit : public flit +{ + public: + Credit() {}; + Credit(int vc, bool is_free_signal, Cycles curTime); + + bool is_free_signal() { return m_is_free_signal; } + + private: + bool m_is_free_signal; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_CREDIT_HH__ diff --git a/src/mem/ruby/network/garnet2.0/CreditLink.hh b/src/mem/ruby/network/garnet2.0/CreditLink.hh new file mode 100644 index 000000000..207fb864d --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/CreditLink.hh @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_CREDIT_LINK_HH__ +#define __MEM_RUBY_NETWORK_GARNET_CREDIT_LINK_HH__ + +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" +#include "params/CreditLink.hh" + +class CreditLink : public NetworkLink +{ + public: + typedef CreditLinkParams Params; + CreditLink(const Params *p) : NetworkLink(p) {} +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_CREDIT_LINK_HH__ diff --git a/src/mem/ruby/network/garnet2.0/CrossbarSwitch.cc b/src/mem/ruby/network/garnet2.0/CrossbarSwitch.cc new file mode 100644 index 000000000..340f56d61 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/CrossbarSwitch.cc @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/CrossbarSwitch.hh" + +#include "base/stl_helpers.hh" +#include "debug/RubyNetwork.hh" +#include "mem/ruby/network/garnet2.0/OutputUnit.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" + +using m5::stl_helpers::deletePointers; + +CrossbarSwitch::CrossbarSwitch(Router *router) + : Consumer(router) +{ + m_router = router; + m_num_vcs = m_router->get_num_vcs(); + m_crossbar_activity = 0; +} + +CrossbarSwitch::~CrossbarSwitch() +{ + deletePointers(m_switch_buffer); +} + +void +CrossbarSwitch::init() +{ + m_output_unit = m_router->get_outputUnit_ref(); + + m_num_inports = m_router->get_num_inports(); + m_switch_buffer.resize(m_num_inports); + for (int i = 0; i < m_num_inports; i++) { + m_switch_buffer[i] = new flitBuffer(); + } +} + +/* + * The wakeup function of the CrossbarSwitch loops through all input ports, + * and sends the winning flit (from SA) out of its output port on to the + * output link. The output link is scheduled for wakeup in the next cycle. + */ + +void +CrossbarSwitch::wakeup() +{ + DPRINTF(RubyNetwork, "CrossbarSwitch at Router %d woke up " + "at time: %lld\n", + m_router->get_id(), m_router->curCycle()); + + for (int inport = 0; inport < m_num_inports; inport++) { + if (!m_switch_buffer[inport]->isReady(m_router->curCycle())) + continue; + + flit *t_flit = m_switch_buffer[inport]->peekTopFlit(); + if (t_flit->is_stage(ST_, m_router->curCycle())) { + int outport = t_flit->get_outport(); + + // flit performs LT_ in the next cycle + t_flit->advance_stage(LT_, m_router->curCycle() + Cycles(1)); + t_flit->set_time(m_router->curCycle() + Cycles(1)); + + // This will take care of waking up the Network Link + // in the next cycle + m_output_unit[outport]->insert_flit(t_flit); + m_switch_buffer[inport]->getTopFlit(); + m_crossbar_activity++; + } + } +} + +uint32_t +CrossbarSwitch::functionalWrite(Packet *pkt) +{ + uint32_t num_functional_writes = 0; + + for (uint32_t i = 0; i < m_switch_buffer.size(); ++i) { + num_functional_writes += m_switch_buffer[i]->functionalWrite(pkt); + } + + return num_functional_writes; +} diff --git a/src/mem/ruby/network/garnet2.0/CrossbarSwitch.hh b/src/mem/ruby/network/garnet2.0/CrossbarSwitch.hh new file mode 100644 index 000000000..7aaeabf0c --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/CrossbarSwitch.hh @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_CROSSBAR_SWITCH_HH__ +#define __MEM_RUBY_NETWORK_GARNET_CROSSBAR_SWITCH_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/flitBuffer.hh" + +class Router; +class OutputUnit; + +class CrossbarSwitch : public Consumer +{ + public: + CrossbarSwitch(Router *router); + ~CrossbarSwitch(); + void wakeup(); + void init(); + void print(std::ostream& out) const {}; + + inline void update_sw_winner(int inport, flit *t_flit) + { m_switch_buffer[inport]->insert(t_flit); } + + inline double get_crossbar_activity() { return m_crossbar_activity; } + + uint32_t functionalWrite(Packet *pkt); + + private: + int m_num_vcs; + int m_num_inports; + double m_crossbar_activity; + Router *m_router; + std::vector<flitBuffer *> m_switch_buffer; + std::vector<OutputUnit *> m_output_unit; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_CROSSBAR_SWITCH_HH__ diff --git a/src/mem/ruby/network/garnet2.0/GarnetLink.cc b/src/mem/ruby/network/garnet2.0/GarnetLink.cc new file mode 100644 index 000000000..ac5386a52 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/GarnetLink.cc @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/GarnetLink.hh" + +#include "mem/ruby/network/garnet2.0/CreditLink.hh" +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" + +GarnetIntLink::GarnetIntLink(const Params *p) + : BasicLink(p) +{ + // Uni-directional + + m_network_link = p->network_link; + m_credit_link = p->credit_link; +} + +void +GarnetIntLink::init() +{ +} + +void +GarnetIntLink::print(std::ostream& out) const +{ + out << name(); +} + +GarnetIntLink * +GarnetIntLinkParams::create() +{ + return new GarnetIntLink(this); +} + +GarnetExtLink::GarnetExtLink(const Params *p) + : BasicLink(p) +{ + // Bi-directional + + // In + m_network_links[0] = p->network_links[0]; + m_credit_links[0] = p->credit_links[0]; + + // Out + m_network_links[1] = p->network_links[1]; + m_credit_links[1] = p->credit_links[1]; +} + +void +GarnetExtLink::init() +{ +} + +void +GarnetExtLink::print(std::ostream& out) const +{ + out << name(); +} + +GarnetExtLink * +GarnetExtLinkParams::create() +{ + return new GarnetExtLink(this); +} diff --git a/src/mem/ruby/network/garnet2.0/GarnetLink.hh b/src/mem/ruby/network/garnet2.0/GarnetLink.hh new file mode 100644 index 000000000..d7c582950 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/GarnetLink.hh @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_LINK_HH__ +#define __MEM_RUBY_NETWORK_GARNET_LINK_HH__ + +#include <iostream> +#include <string> +#include <vector> + +#include "mem/ruby/network/BasicLink.hh" +#include "mem/ruby/network/garnet2.0/CreditLink.hh" +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" +#include "params/GarnetExtLink.hh" +#include "params/GarnetIntLink.hh" + +class GarnetIntLink : public BasicLink +{ + public: + typedef GarnetIntLinkParams Params; + GarnetIntLink(const Params *p); + + void init(); + + void print(std::ostream& out) const; + + friend class GarnetNetwork; + + protected: + NetworkLink* m_network_link; + CreditLink* m_credit_link; +}; + +inline std::ostream& +operator<<(std::ostream& out, const GarnetIntLink& obj) +{ + obj.print(out); + out << std::flush; + return out; +} + +class GarnetExtLink : public BasicLink +{ + public: + typedef GarnetExtLinkParams Params; + GarnetExtLink(const Params *p); + + void init(); + + void print(std::ostream& out) const; + + friend class GarnetNetwork; + + protected: + NetworkLink* m_network_links[2]; + CreditLink* m_credit_links[2]; +}; + +inline std::ostream& +operator<<(std::ostream& out, const GarnetExtLink& obj) +{ + obj.print(out); + out << std::flush; + return out; +} + +#endif // __MEM_RUBY_NETWORK_GARNET_LINK_HH__ diff --git a/src/mem/ruby/network/garnet2.0/GarnetLink.py b/src/mem/ruby/network/garnet2.0/GarnetLink.py new file mode 100644 index 000000000..fc5632d49 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/GarnetLink.py @@ -0,0 +1,79 @@ +# Copyright (c) 2008 Princeton University +# Copyright (c) 2009 Advanced Micro Devices, Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# Authors: Steve Reinhardt +# Brad Beckmann + +from m5.params import * +from m5.proxy import * +from ClockedObject import ClockedObject +from BasicLink import BasicIntLink, BasicExtLink + +class NetworkLink(ClockedObject): + type = 'NetworkLink' + cxx_header = "mem/ruby/network/garnet2.0/NetworkLink.hh" + link_id = Param.Int(Parent.link_id, "link id") + link_latency = Param.Cycles(Parent.latency, "link latency") + vcs_per_vnet = Param.Int(Parent.vcs_per_vnet, + "virtual channels per virtual network") + virt_nets = Param.Int(Parent.number_of_virtual_networks, + "number of virtual networks") + +class CreditLink(NetworkLink): + type = 'CreditLink' + cxx_header = "mem/ruby/network/garnet2.0/CreditLink.hh" + +# Interior fixed pipeline links between routers +class GarnetIntLink(BasicIntLink): + type = 'GarnetIntLink' + cxx_header = "mem/ruby/network/garnet2.0/GarnetLink.hh" + # The internal link includes one forward link (for flit) + # and one backward flow-control link (for credit) + network_link = Param.NetworkLink(NetworkLink(), "forward link") + credit_link = Param.CreditLink(CreditLink(), "backward flow-control link") + +# Exterior fixed pipeline links between a router and a controller +class GarnetExtLink(BasicExtLink): + type = 'GarnetExtLink' + cxx_header = "mem/ruby/network/garnet2.0/GarnetLink.hh" + # The external link is bi-directional. + # It includes two forward links (for flits) + # and two backward flow-control links (for credits), + # one per direction + _nls = [] + # In uni-directional link + _nls.append(NetworkLink()); + # Out uni-directional link + _nls.append(NetworkLink()); + network_links = VectorParam.NetworkLink(_nls, "forward links") + + _cls = [] + # In uni-directional link + _cls.append(CreditLink()); + # Out uni-directional link + _cls.append(CreditLink()); + credit_links = VectorParam.CreditLink(_cls, "backward flow-control links") diff --git a/src/mem/ruby/network/garnet2.0/GarnetNetwork.cc b/src/mem/ruby/network/garnet2.0/GarnetNetwork.cc new file mode 100644 index 000000000..5fa764457 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/GarnetNetwork.cc @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/GarnetNetwork.hh" + +#include <cassert> + +#include "base/cast.hh" +#include "base/stl_helpers.hh" +#include "mem/ruby/common/NetDest.hh" +#include "mem/ruby/network/MessageBuffer.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/CreditLink.hh" +#include "mem/ruby/network/garnet2.0/GarnetLink.hh" +#include "mem/ruby/network/garnet2.0/NetworkInterface.hh" +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" +#include "mem/ruby/system/RubySystem.hh" + +using namespace std; +using m5::stl_helpers::deletePointers; + +/* + * GarnetNetwork sets up the routers and links and collects stats. + * Default parameters (GarnetNetwork.py) can be overwritten from command line + * (see configs/network/Network.py) + */ + +GarnetNetwork::GarnetNetwork(const Params *p) + : Network(p) +{ + m_num_rows = p->num_rows; + m_ni_flit_size = p->ni_flit_size; + m_vcs_per_vnet = p->vcs_per_vnet; + m_buffers_per_data_vc = p->buffers_per_data_vc; + m_buffers_per_ctrl_vc = p->buffers_per_ctrl_vc; + m_routing_algorithm = p->routing_algorithm; + + m_enable_fault_model = p->enable_fault_model; + if (m_enable_fault_model) + fault_model = p->fault_model; + + m_vnet_type.resize(m_virtual_networks); + + for (int i = 0 ; i < m_virtual_networks ; i++) { + if (m_vnet_type_names[i] == "response") + m_vnet_type[i] = DATA_VNET_; // carries data (and ctrl) packets + else + m_vnet_type[i] = CTRL_VNET_; // carries only ctrl packets + } + + // record the routers + for (vector<BasicRouter*>::const_iterator i = p->routers.begin(); + i != p->routers.end(); ++i) { + Router* router = safe_cast<Router*>(*i); + m_routers.push_back(router); + + // initialize the router's network pointers + router->init_net_ptr(this); + } + + // record the network interfaces + for (vector<ClockedObject*>::const_iterator i = p->netifs.begin(); + i != p->netifs.end(); ++i) { + NetworkInterface *ni = safe_cast<NetworkInterface *>(*i); + m_nis.push_back(ni); + ni->init_net_ptr(this); + } +} + +void +GarnetNetwork::init() +{ + Network::init(); + + for (int i=0; i < m_nodes; i++) { + m_nis[i]->addNode(m_toNetQueues[i], m_fromNetQueues[i]); + } + + // The topology pointer should have already been initialized in the + // parent network constructor + assert(m_topology_ptr != NULL); + m_topology_ptr->createLinks(this); + + // Initialize topology specific parameters + if (getNumRows() > 0) { + // Only for Mesh topology + // m_num_rows and m_num_cols are only used for + // implementing XY or custom routing in RoutingUnit.cc + m_num_rows = getNumRows(); + m_num_cols = m_routers.size() / m_num_rows; + assert(m_num_rows * m_num_cols == m_routers.size()); + } else { + m_num_rows = -1; + m_num_cols = -1; + } + + // FaultModel: declare each router to the fault model + if (isFaultModelEnabled()) { + for (vector<Router*>::const_iterator i= m_routers.begin(); + i != m_routers.end(); ++i) { + Router* router = safe_cast<Router*>(*i); + int router_id M5_VAR_USED = + fault_model->declare_router(router->get_num_inports(), + router->get_num_outports(), + router->get_vc_per_vnet(), + getBuffersPerDataVC(), + getBuffersPerCtrlVC()); + assert(router_id == router->get_id()); + router->printAggregateFaultProbability(cout); + router->printFaultVector(cout); + } + } +} + +GarnetNetwork::~GarnetNetwork() +{ + deletePointers(m_routers); + deletePointers(m_nis); + deletePointers(m_networklinks); + deletePointers(m_creditlinks); +} + +/* + * This function creates a link from the Network Interface (NI) + * into the Network. + * It creates a Network Link from the NI to a Router and a Credit Link from + * the Router to the NI +*/ + +void +GarnetNetwork::makeExtInLink(NodeID src, SwitchID dest, BasicLink* link, + const NetDest& routing_table_entry) +{ + assert(src < m_nodes); + + GarnetExtLink* garnet_link = safe_cast<GarnetExtLink*>(link); + + // GarnetExtLink is bi-directional + NetworkLink* net_link = garnet_link->m_network_links[LinkDirection_In]; + net_link->setType(EXT_IN_); + CreditLink* credit_link = garnet_link->m_credit_links[LinkDirection_In]; + + m_networklinks.push_back(net_link); + m_creditlinks.push_back(credit_link); + + PortDirection dst_inport_dirn = "Local"; + m_routers[dest]->addInPort(dst_inport_dirn, net_link, credit_link); + m_nis[src]->addOutPort(net_link, credit_link, dest); +} + +/* + * This function creates a link from the Network to a NI. + * It creates a Network Link from a Router to the NI and + * a Credit Link from NI to the Router +*/ + +void +GarnetNetwork::makeExtOutLink(SwitchID src, NodeID dest, BasicLink* link, + const NetDest& routing_table_entry) +{ + assert(dest < m_nodes); + assert(src < m_routers.size()); + assert(m_routers[src] != NULL); + + GarnetExtLink* garnet_link = safe_cast<GarnetExtLink*>(link); + + // GarnetExtLink is bi-directional + NetworkLink* net_link = garnet_link->m_network_links[LinkDirection_Out]; + net_link->setType(EXT_OUT_); + CreditLink* credit_link = garnet_link->m_credit_links[LinkDirection_Out]; + + m_networklinks.push_back(net_link); + m_creditlinks.push_back(credit_link); + + PortDirection src_outport_dirn = "Local"; + m_routers[src]->addOutPort(src_outport_dirn, net_link, + routing_table_entry, + link->m_weight, credit_link); + m_nis[dest]->addInPort(net_link, credit_link); +} + +/* + * This function creates an internal network link between two routers. + * It adds both the network link and an opposite credit link. +*/ + +void +GarnetNetwork::makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, + const NetDest& routing_table_entry, + PortDirection src_outport_dirn, + PortDirection dst_inport_dirn) +{ + GarnetIntLink* garnet_link = safe_cast<GarnetIntLink*>(link); + + // GarnetIntLink is unidirectional + NetworkLink* net_link = garnet_link->m_network_link; + net_link->setType(INT_); + CreditLink* credit_link = garnet_link->m_credit_link; + + m_networklinks.push_back(net_link); + m_creditlinks.push_back(credit_link); + + m_routers[dest]->addInPort(dst_inport_dirn, net_link, credit_link); + m_routers[src]->addOutPort(src_outport_dirn, net_link, + routing_table_entry, + link->m_weight, credit_link); +} + +// Total routers in the network +int +GarnetNetwork::getNumRouters() +{ + return m_routers.size(); +} + +// Get ID of router connected to a NI. +int +GarnetNetwork::get_router_id(int ni) +{ + return m_nis[ni]->get_router_id(); +} + +void +GarnetNetwork::regStats() +{ + Network::regStats(); + + // Packets + m_packets_received + .init(m_virtual_networks) + .name(name() + ".packets_received") + .flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline) + ; + + m_packets_injected + .init(m_virtual_networks) + .name(name() + ".packets_injected") + .flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline) + ; + + m_packet_network_latency + .init(m_virtual_networks) + .name(name() + ".packet_network_latency") + .flags(Stats::oneline) + ; + + m_packet_queueing_latency + .init(m_virtual_networks) + .name(name() + ".packet_queueing_latency") + .flags(Stats::oneline) + ; + + for (int i = 0; i < m_virtual_networks; i++) { + m_packets_received.subname(i, csprintf("vnet-%i", i)); + m_packets_injected.subname(i, csprintf("vnet-%i", i)); + m_packet_network_latency.subname(i, csprintf("vnet-%i", i)); + m_packet_queueing_latency.subname(i, csprintf("vnet-%i", i)); + } + + m_avg_packet_vnet_latency + .name(name() + ".average_packet_vnet_latency") + .flags(Stats::oneline); + m_avg_packet_vnet_latency = + m_packet_network_latency / m_packets_received; + + m_avg_packet_vqueue_latency + .name(name() + ".average_packet_vqueue_latency") + .flags(Stats::oneline); + m_avg_packet_vqueue_latency = + m_packet_queueing_latency / m_packets_received; + + m_avg_packet_network_latency + .name(name() + ".average_packet_network_latency"); + m_avg_packet_network_latency = + sum(m_packet_network_latency) / sum(m_packets_received); + + m_avg_packet_queueing_latency + .name(name() + ".average_packet_queueing_latency"); + m_avg_packet_queueing_latency + = sum(m_packet_queueing_latency) / sum(m_packets_received); + + m_avg_packet_latency + .name(name() + ".average_packet_latency"); + m_avg_packet_latency + = m_avg_packet_network_latency + m_avg_packet_queueing_latency; + + // Flits + m_flits_received + .init(m_virtual_networks) + .name(name() + ".flits_received") + .flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline) + ; + + m_flits_injected + .init(m_virtual_networks) + .name(name() + ".flits_injected") + .flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline) + ; + + m_flit_network_latency + .init(m_virtual_networks) + .name(name() + ".flit_network_latency") + .flags(Stats::oneline) + ; + + m_flit_queueing_latency + .init(m_virtual_networks) + .name(name() + ".flit_queueing_latency") + .flags(Stats::oneline) + ; + + for (int i = 0; i < m_virtual_networks; i++) { + m_flits_received.subname(i, csprintf("vnet-%i", i)); + m_flits_injected.subname(i, csprintf("vnet-%i", i)); + m_flit_network_latency.subname(i, csprintf("vnet-%i", i)); + m_flit_queueing_latency.subname(i, csprintf("vnet-%i", i)); + } + + m_avg_flit_vnet_latency + .name(name() + ".average_flit_vnet_latency") + .flags(Stats::oneline); + m_avg_flit_vnet_latency = m_flit_network_latency / m_flits_received; + + m_avg_flit_vqueue_latency + .name(name() + ".average_flit_vqueue_latency") + .flags(Stats::oneline); + m_avg_flit_vqueue_latency = + m_flit_queueing_latency / m_flits_received; + + m_avg_flit_network_latency + .name(name() + ".average_flit_network_latency"); + m_avg_flit_network_latency = + sum(m_flit_network_latency) / sum(m_flits_received); + + m_avg_flit_queueing_latency + .name(name() + ".average_flit_queueing_latency"); + m_avg_flit_queueing_latency = + sum(m_flit_queueing_latency) / sum(m_flits_received); + + m_avg_flit_latency + .name(name() + ".average_flit_latency"); + m_avg_flit_latency = + m_avg_flit_network_latency + m_avg_flit_queueing_latency; + + + // Hops + m_avg_hops.name(name() + ".average_hops"); + m_avg_hops = m_total_hops / sum(m_flits_received); + + // Links + m_total_ext_in_link_utilization + .name(name() + ".ext_in_link_utilization"); + m_total_ext_out_link_utilization + .name(name() + ".ext_out_link_utilization"); + m_total_int_link_utilization + .name(name() + ".int_link_utilization"); + m_average_link_utilization + .name(name() + ".avg_link_utilization"); + + m_average_vc_load + .init(m_virtual_networks * m_vcs_per_vnet) + .name(name() + ".avg_vc_load") + .flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline) + ; +} + +void +GarnetNetwork::collateStats() +{ + RubySystem *rs = params()->ruby_system; + double time_delta = double(curCycle() - rs->getStartCycle()); + + for (int i = 0; i < m_networklinks.size(); i++) { + link_type type = m_networklinks[i]->getType(); + int activity = m_networklinks[i]->getLinkUtilization(); + + if (type == EXT_IN_) + m_total_ext_in_link_utilization += activity; + else if (type == EXT_OUT_) + m_total_ext_out_link_utilization += activity; + else if (type == INT_) + m_total_int_link_utilization += activity; + + m_average_link_utilization += + (double(activity) / time_delta); + + vector<unsigned int> vc_load = m_networklinks[i]->getVcLoad(); + for (int j = 0; j < vc_load.size(); j++) { + m_average_vc_load[j] += ((double)vc_load[j] / time_delta); + } + } + + // Ask the routers to collate their statistics + for (int i = 0; i < m_routers.size(); i++) { + m_routers[i]->collateStats(); + } +} + +void +GarnetNetwork::print(ostream& out) const +{ + out << "[GarnetNetwork]"; +} + +GarnetNetwork * +GarnetNetworkParams::create() +{ + return new GarnetNetwork(this); +} + +uint32_t +GarnetNetwork::functionalWrite(Packet *pkt) +{ + uint32_t num_functional_writes = 0; + + for (unsigned int i = 0; i < m_routers.size(); i++) { + num_functional_writes += m_routers[i]->functionalWrite(pkt); + } + + for (unsigned int i = 0; i < m_nis.size(); ++i) { + num_functional_writes += m_nis[i]->functionalWrite(pkt); + } + + for (unsigned int i = 0; i < m_networklinks.size(); ++i) { + num_functional_writes += m_networklinks[i]->functionalWrite(pkt); + } + + return num_functional_writes; +} diff --git a/src/mem/ruby/network/garnet2.0/GarnetNetwork.hh b/src/mem/ruby/network/garnet2.0/GarnetNetwork.hh new file mode 100644 index 000000000..3ced88740 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/GarnetNetwork.hh @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_NETWORK_HH__ +#define __MEM_RUBY_NETWORK_GARNET_NETWORK_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/network/Network.hh" +#include "mem/ruby/network/fault_model/FaultModel.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "params/GarnetNetwork.hh" + +class FaultModel; +class NetworkInterface; +class Router; +class NetDest; +class NetworkLink; +class CreditLink; + +class GarnetNetwork : public Network +{ + public: + typedef GarnetNetworkParams Params; + GarnetNetwork(const Params *p); + + ~GarnetNetwork(); + void init(); + + // Configuration (set externally) + + // for 2D topology + int getNumRows() const { return m_num_rows; } + int getNumCols() { return m_num_cols; } + + // for network + uint32_t getNiFlitSize() const { return m_ni_flit_size; } + uint32_t getVCsPerVnet() const { return m_vcs_per_vnet; } + uint32_t getBuffersPerDataVC() { return m_buffers_per_data_vc; } + uint32_t getBuffersPerCtrlVC() { return m_buffers_per_ctrl_vc; } + int getRoutingAlgorithm() const { return m_routing_algorithm; } + + bool isFaultModelEnabled() const { return m_enable_fault_model; } + FaultModel* fault_model; + + + // Internal configuration + bool isVNetOrdered(int vnet) const { return m_ordered[vnet]; } + VNET_type + get_vnet_type(int vc) + { + int vnet = vc/getVCsPerVnet(); + return m_vnet_type[vnet]; + } + int getNumRouters(); + int get_router_id(int ni); + + + // Methods used by Topology to setup the network + void makeExtOutLink(SwitchID src, NodeID dest, BasicLink* link, + const NetDest& routing_table_entry); + void makeExtInLink(NodeID src, SwitchID dest, BasicLink* link, + const NetDest& routing_table_entry); + void makeInternalLink(SwitchID src, SwitchID dest, BasicLink* link, + const NetDest& routing_table_entry, + PortDirection src_outport_dirn, + PortDirection dest_inport_dirn); + + //! Function for performing a functional write. The return value + //! indicates the number of messages that were written. + uint32_t functionalWrite(Packet *pkt); + + // Stats + void collateStats(); + void regStats(); + void print(std::ostream& out) const; + + // increment counters + void increment_injected_packets(int vnet) { m_packets_injected[vnet]++; } + void increment_received_packets(int vnet) { m_packets_received[vnet]++; } + + void + increment_packet_network_latency(Cycles latency, int vnet) + { + m_packet_network_latency[vnet] += latency; + } + + void + increment_packet_queueing_latency(Cycles latency, int vnet) + { + m_packet_queueing_latency[vnet] += latency; + } + + void increment_injected_flits(int vnet) { m_flits_injected[vnet]++; } + void increment_received_flits(int vnet) { m_flits_received[vnet]++; } + + void + increment_flit_network_latency(Cycles latency, int vnet) + { + m_flit_network_latency[vnet] += latency; + } + + void + increment_flit_queueing_latency(Cycles latency, int vnet) + { + m_flit_queueing_latency[vnet] += latency; + } + + void + increment_total_hops(int hops) + { + m_total_hops += hops; + } + + protected: + // Configuration + int m_num_rows; + int m_num_cols; + uint32_t m_ni_flit_size; + uint32_t m_vcs_per_vnet; + uint32_t m_buffers_per_ctrl_vc; + uint32_t m_buffers_per_data_vc; + int m_routing_algorithm; + bool m_enable_fault_model; + + // Statistical variables + Stats::Vector m_packets_received; + Stats::Vector m_packets_injected; + Stats::Vector m_packet_network_latency; + Stats::Vector m_packet_queueing_latency; + + Stats::Formula m_avg_packet_vnet_latency; + Stats::Formula m_avg_packet_vqueue_latency; + Stats::Formula m_avg_packet_network_latency; + Stats::Formula m_avg_packet_queueing_latency; + Stats::Formula m_avg_packet_latency; + + Stats::Vector m_flits_received; + Stats::Vector m_flits_injected; + Stats::Vector m_flit_network_latency; + Stats::Vector m_flit_queueing_latency; + + Stats::Formula m_avg_flit_vnet_latency; + Stats::Formula m_avg_flit_vqueue_latency; + Stats::Formula m_avg_flit_network_latency; + Stats::Formula m_avg_flit_queueing_latency; + Stats::Formula m_avg_flit_latency; + + Stats::Scalar m_total_ext_in_link_utilization; + Stats::Scalar m_total_ext_out_link_utilization; + Stats::Scalar m_total_int_link_utilization; + Stats::Scalar m_average_link_utilization; + Stats::Vector m_average_vc_load; + + Stats::Scalar m_total_hops; + Stats::Formula m_avg_hops; + + private: + GarnetNetwork(const GarnetNetwork& obj); + GarnetNetwork& operator=(const GarnetNetwork& obj); + + std::vector<VNET_type > m_vnet_type; + std::vector<Router *> m_routers; // All Routers in Network + std::vector<NetworkLink *> m_networklinks; // All flit links in the network + std::vector<CreditLink *> m_creditlinks; // All credit links in the network + std::vector<NetworkInterface *> m_nis; // All NI's in Network +}; + +inline std::ostream& +operator<<(std::ostream& out, const GarnetNetwork& obj) +{ + obj.print(out); + out << std::flush; + return out; +} + +#endif // __MEM_RUBY_NETWORK_GARNET_NETWORK_HH__ diff --git a/src/mem/ruby/network/garnet2.0/GarnetNetwork.py b/src/mem/ruby/network/garnet2.0/GarnetNetwork.py new file mode 100644 index 000000000..704532782 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/GarnetNetwork.py @@ -0,0 +1,68 @@ +# Copyright (c) 2008 Princeton University +# Copyright (c) 2009 Advanced Micro Devices, Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# Author: Tushar Krishna +# + +from m5.params import * +from m5.proxy import * +from Network import RubyNetwork +from BasicRouter import BasicRouter +from ClockedObject import ClockedObject + +class GarnetNetwork(RubyNetwork): + type = 'GarnetNetwork' + cxx_header = "mem/ruby/network/garnet2.0/GarnetNetwork.hh" + num_rows = Param.Int(0, "number of rows if 2D (mesh/torus/..) topology"); + ni_flit_size = Param.UInt32(16, "network interface flit size in bytes") + vcs_per_vnet = Param.UInt32(4, "virtual channels per virtual network"); + buffers_per_data_vc = Param.UInt32(4, "buffers per data virtual channel"); + buffers_per_ctrl_vc = Param.UInt32(1, "buffers per ctrl virtual channel"); + routing_algorithm = Param.Int(0, + "0: Weight-based Table, 1: XY, 2: Custom"); + enable_fault_model = Param.Bool(False, "enable network fault model"); + fault_model = Param.FaultModel(NULL, "network fault model"); + +class GarnetNetworkInterface(ClockedObject): + type = 'GarnetNetworkInterface' + cxx_class = 'NetworkInterface' + cxx_header = "mem/ruby/network/garnet2.0/NetworkInterface.hh" + + id = Param.UInt32("ID in relation to other network interfaces") + vcs_per_vnet = Param.UInt32(Parent.vcs_per_vnet, + "virtual channels per virtual network") + virt_nets = Param.UInt32(Parent.number_of_virtual_networks, + "number of virtual networks") + +class GarnetRouter(BasicRouter): + type = 'GarnetRouter' + cxx_class = 'Router' + cxx_header = "mem/ruby/network/garnet2.0/Router.hh" + vcs_per_vnet = Param.UInt32(Parent.vcs_per_vnet, + "virtual channels per virtual network") + virt_nets = Param.UInt32(Parent.number_of_virtual_networks, + "number of virtual networks") diff --git a/src/mem/ruby/network/garnet2.0/InputUnit.cc b/src/mem/ruby/network/garnet2.0/InputUnit.cc new file mode 100644 index 000000000..c03bf2a09 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/InputUnit.cc @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/InputUnit.hh" + +#include "base/stl_helpers.hh" +#include "debug/RubyNetwork.hh" +#include "mem/ruby/network/garnet2.0/Credit.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" + +using namespace std; +using m5::stl_helpers::deletePointers; + +InputUnit::InputUnit(int id, PortDirection direction, Router *router) + : Consumer(router) +{ + m_id = id; + m_direction = direction; + m_router = router; + m_num_vcs = m_router->get_num_vcs(); + m_vc_per_vnet = m_router->get_vc_per_vnet(); + + m_num_buffer_reads.resize(m_num_vcs/m_vc_per_vnet); + m_num_buffer_writes.resize(m_num_vcs/m_vc_per_vnet); + for (int i = 0; i < m_num_buffer_reads.size(); i++) { + m_num_buffer_reads[i] = 0; + m_num_buffer_writes[i] = 0; + } + + creditQueue = new flitBuffer(); + // Instantiating the virtual channels + m_vcs.resize(m_num_vcs); + for (int i=0; i < m_num_vcs; i++) { + m_vcs[i] = new VirtualChannel(i); + } +} + +InputUnit::~InputUnit() +{ + delete creditQueue; + deletePointers(m_vcs); +} + +/* + * The InputUnit wakeup function reads the input flit from its input link. + * Each flit arrives with an input VC. + * For HEAD/HEAD_TAIL flits, performs route computation, + * and updates route in the input VC. + * The flit is buffered for (m_latency - 1) cycles in the input VC + * and marked as valid for SwitchAllocation starting that cycle. + * + */ + +void +InputUnit::wakeup() +{ + flit *t_flit; + if (m_in_link->isReady(m_router->curCycle())) { + + t_flit = m_in_link->consumeLink(); + int vc = t_flit->get_vc(); + t_flit->increment_hops(); // for stats + + if ((t_flit->get_type() == HEAD_) || + (t_flit->get_type() == HEAD_TAIL_)) { + + assert(m_vcs[vc]->get_state() == IDLE_); + set_vc_active(vc, m_router->curCycle()); + + // Route computation for this vc + int outport = m_router->route_compute(t_flit->get_route(), + m_id, m_direction); + + // Update output port in VC + // All flits in this packet will use this output port + // The output port field in the flit is updated after it wins SA + grant_outport(vc, outport); + + } else { + assert(m_vcs[vc]->get_state() == ACTIVE_); + } + + + // Buffer the flit + m_vcs[vc]->insertFlit(t_flit); + + int vnet = vc/m_vc_per_vnet; + // number of writes same as reads + // any flit that is written will be read only once + m_num_buffer_writes[vnet]++; + m_num_buffer_reads[vnet]++; + + Cycles pipe_stages = m_router->get_pipe_stages(); + if (pipe_stages == 1) { + // 1-cycle router + // Flit goes for SA directly + t_flit->advance_stage(SA_, m_router->curCycle()); + } else { + assert(pipe_stages > 1); + // Router delay is modeled by making flit wait in buffer for + // (pipe_stages cycles - 1) cycles before going for SA + + Cycles wait_time = pipe_stages - Cycles(1); + t_flit->advance_stage(SA_, m_router->curCycle() + wait_time); + + // Wakeup the router in that cycle to perform SA + m_router->schedule_wakeup(Cycles(wait_time)); + } + } +} + +// Send a credit back to upstream router for this VC. +// Called by SwitchAllocator when the flit in this VC wins the Switch. +void +InputUnit::increment_credit(int in_vc, bool free_signal, Cycles curTime) +{ + Credit *t_credit = new Credit(in_vc, free_signal, curTime); + creditQueue->insert(t_credit); + m_credit_link->scheduleEventAbsolute(m_router->clockEdge(Cycles(1))); +} + + +uint32_t +InputUnit::functionalWrite(Packet *pkt) +{ + uint32_t num_functional_writes = 0; + for (int i=0; i < m_num_vcs; i++) { + num_functional_writes += m_vcs[i]->functionalWrite(pkt); + } + + return num_functional_writes; +} + +void +InputUnit::resetStats() +{ + for (int j = 0; j < m_num_buffer_reads.size(); j++) { + m_num_buffer_reads[j] = 0; + m_num_buffer_writes[j] = 0; + } +} diff --git a/src/mem/ruby/network/garnet2.0/InputUnit.hh b/src/mem/ruby/network/garnet2.0/InputUnit.hh new file mode 100644 index 000000000..26803ed86 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/InputUnit.hh @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_INPUT_UNIT_HH__ +#define __MEM_RUBY_NETWORK_GARNET_INPUT_UNIT_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/CreditLink.hh" +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" +#include "mem/ruby/network/garnet2.0/VirtualChannel.hh" +#include "mem/ruby/network/garnet2.0/flitBuffer.hh" + +class InputUnit : public Consumer +{ + public: + InputUnit(int id, PortDirection direction, Router *router); + ~InputUnit(); + + void wakeup(); + void print(std::ostream& out) const {}; + + inline PortDirection get_direction() { return m_direction; } + + inline void + set_vc_idle(int vc, Cycles curTime) + { + m_vcs[vc]->set_idle(curTime); + } + + inline void + set_vc_active(int vc, Cycles curTime) + { + m_vcs[vc]->set_active(curTime); + } + + inline void + grant_outport(int vc, int outport) + { + m_vcs[vc]->set_outport(outport); + } + + inline void + grant_outvc(int vc, int outvc) + { + m_vcs[vc]->set_outvc(outvc); + } + + inline int + get_outport(int invc) + { + return m_vcs[invc]->get_outport(); + } + + inline int + get_outvc(int invc) + { + return m_vcs[invc]->get_outvc(); + } + + inline Cycles + get_enqueue_time(int invc) + { + return m_vcs[invc]->get_enqueue_time(); + } + + void increment_credit(int in_vc, bool free_signal, Cycles curTime); + + inline flit* + peekTopFlit(int vc) + { + return m_vcs[vc]->peekTopFlit(); + } + + inline flit* + getTopFlit(int vc) + { + return m_vcs[vc]->getTopFlit(); + } + + inline bool + need_stage(int vc, flit_stage stage, Cycles time) + { + return m_vcs[vc]->need_stage(stage, time); + } + + inline bool + isReady(int invc, Cycles curTime) + { + return m_vcs[invc]->isReady(curTime); + } + + flitBuffer* getCreditQueue() { return creditQueue; } + + inline void + set_in_link(NetworkLink *link) + { + m_in_link = link; + } + + inline int get_inlink_id() { return m_in_link->get_id(); } + + inline void + set_credit_link(CreditLink *credit_link) + { + m_credit_link = credit_link; + } + + double get_buf_read_activity(unsigned int vnet) const + { return m_num_buffer_reads[vnet]; } + double get_buf_write_activity(unsigned int vnet) const + { return m_num_buffer_writes[vnet]; } + + uint32_t functionalWrite(Packet *pkt); + void resetStats(); + + private: + int m_id; + PortDirection m_direction; + int m_num_vcs; + int m_vc_per_vnet; + + Router *m_router; + NetworkLink *m_in_link; + CreditLink *m_credit_link; + flitBuffer *creditQueue; + + // Input Virtual channels + std::vector<VirtualChannel *> m_vcs; + + // Statistical variables + std::vector<double> m_num_buffer_writes; + std::vector<double> m_num_buffer_reads; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_INPUT_UNIT_HH__ diff --git a/src/mem/ruby/network/garnet2.0/NetworkInterface.cc b/src/mem/ruby/network/garnet2.0/NetworkInterface.cc new file mode 100644 index 000000000..6bdaf39af --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/NetworkInterface.cc @@ -0,0 +1,443 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/NetworkInterface.hh" + +#include <cassert> +#include <cmath> + +#include "base/cast.hh" +#include "base/stl_helpers.hh" +#include "debug/RubyNetwork.hh" +#include "mem/ruby/network/MessageBuffer.hh" +#include "mem/ruby/network/garnet2.0/Credit.hh" +#include "mem/ruby/network/garnet2.0/flitBuffer.hh" +#include "mem/ruby/slicc_interface/Message.hh" + +using namespace std; +using m5::stl_helpers::deletePointers; + +NetworkInterface::NetworkInterface(const Params *p) + : ClockedObject(p), Consumer(this), m_id(p->id), + m_virtual_networks(p->virt_nets), m_vc_per_vnet(p->vcs_per_vnet), + m_num_vcs(m_vc_per_vnet * m_virtual_networks) +{ + m_router_id = -1; + m_vc_round_robin = 0; + m_ni_out_vcs.resize(m_num_vcs); + m_ni_out_vcs_enqueue_time.resize(m_num_vcs); + outCreditQueue = new flitBuffer(); + + // instantiating the NI flit buffers + for (int i = 0; i < m_num_vcs; i++) { + m_ni_out_vcs[i] = new flitBuffer(); + m_ni_out_vcs_enqueue_time[i] = Cycles(INFINITE_); + } + + m_vc_allocator.resize(m_virtual_networks); // 1 allocator per vnet + for (int i = 0; i < m_virtual_networks; i++) { + m_vc_allocator[i] = 0; + } +} + +void +NetworkInterface::init() +{ + for (int i = 0; i < m_num_vcs; i++) { + m_out_vc_state.push_back(new OutVcState(i, m_net_ptr)); + } +} + +NetworkInterface::~NetworkInterface() +{ + deletePointers(m_out_vc_state); + deletePointers(m_ni_out_vcs); + delete outCreditQueue; + delete outFlitQueue; +} + +void +NetworkInterface::addInPort(NetworkLink *in_link, + CreditLink *credit_link) +{ + inNetLink = in_link; + in_link->setLinkConsumer(this); + outCreditLink = credit_link; + credit_link->setSourceQueue(outCreditQueue); +} + +void +NetworkInterface::addOutPort(NetworkLink *out_link, + CreditLink *credit_link, + SwitchID router_id) +{ + inCreditLink = credit_link; + credit_link->setLinkConsumer(this); + + outNetLink = out_link; + outFlitQueue = new flitBuffer(); + out_link->setSourceQueue(outFlitQueue); + + m_router_id = router_id; +} + +void +NetworkInterface::addNode(vector<MessageBuffer *>& in, + vector<MessageBuffer *>& out) +{ + inNode_ptr = in; + outNode_ptr = out; + + for (auto& it : in) { + if (it != nullptr) { + it->setConsumer(this); + } + } +} + + +/* + * The NI wakeup checks whether there are any ready messages in the protocol + * buffer. If yes, it picks that up, flitisizes it into a number of flits and + * puts it into an output buffer and schedules the output link. On a wakeup + * it also checks whether there are flits in the input link. If yes, it picks + * them up and if the flit is a tail, the NI inserts the corresponding message + * into the protocol buffer. It also checks for credits being sent by the + * downstream router. + */ + +void +NetworkInterface::wakeup() +{ + DPRINTF(RubyNetwork, "Network Interface %d connected to router %d " + "woke up at time: %lld\n", m_id, m_router_id, curCycle()); + + MsgPtr msg_ptr; + Tick curTime = clockEdge(); + + // Checking for messages coming from the protocol + // can pick up a message/cycle for each virtual net + for (int vnet = 0; vnet < inNode_ptr.size(); ++vnet) { + MessageBuffer *b = inNode_ptr[vnet]; + if (b == nullptr) { + continue; + } + + if (b->isReady(curTime)) { // Is there a message waiting + msg_ptr = b->peekMsgPtr(); + if (flitisizeMessage(msg_ptr, vnet)) { + b->dequeue(curTime); + } else { + break; + } + } + } + + scheduleOutputLink(); + checkReschedule(); + + /*********** Check the incoming flit link **********/ + + if (inNetLink->isReady(curCycle())) { + flit *t_flit = inNetLink->consumeLink(); + bool free_signal = false; + if (t_flit->get_type() == TAIL_ || t_flit->get_type() == HEAD_TAIL_) { + free_signal = true; + + // enqueue into the protocol buffers + outNode_ptr[t_flit->get_vnet()]->enqueue( + t_flit->get_msg_ptr(), curTime, cyclesToTicks(Cycles(1))); + } + // Simply send a credit back since we are not buffering + // this flit in the NI + Credit *t_credit = new Credit(t_flit->get_vc(), free_signal, + curCycle()); + outCreditQueue->insert(t_credit); + outCreditLink-> + scheduleEventAbsolute(clockEdge(Cycles(1))); + + int vnet = t_flit->get_vnet(); + + // Update Stats + + // Latency + m_net_ptr->increment_received_flits(vnet); + Cycles network_delay = curCycle() - t_flit->get_enqueue_time(); + Cycles queueing_delay = t_flit->get_src_delay(); + + m_net_ptr->increment_flit_network_latency(network_delay, vnet); + m_net_ptr->increment_flit_queueing_latency(queueing_delay, vnet); + + if (t_flit->get_type() == TAIL_ || t_flit->get_type() == HEAD_TAIL_) { + m_net_ptr->increment_received_packets(vnet); + m_net_ptr->increment_packet_network_latency(network_delay, vnet); + m_net_ptr->increment_packet_queueing_latency(queueing_delay, vnet); + } + + // Hops + m_net_ptr->increment_total_hops(t_flit->get_route().hops_traversed); + + delete t_flit; + } + + /****************** Check the incoming credit link *******/ + + if (inCreditLink->isReady(curCycle())) { + Credit *t_credit = (Credit*) inCreditLink->consumeLink(); + m_out_vc_state[t_credit->get_vc()]->increment_credit(); + if (t_credit->is_free_signal()) { + m_out_vc_state[t_credit->get_vc()]->setState(IDLE_, curCycle()); + } + delete t_credit; + } +} + + +// Embed the protocol message into flits +bool +NetworkInterface::flitisizeMessage(MsgPtr msg_ptr, int vnet) +{ + Message *net_msg_ptr = msg_ptr.get(); + NetDest net_msg_dest = net_msg_ptr->getDestination(); + + // gets all the destinations associated with this message. + vector<NodeID> dest_nodes = net_msg_dest.getAllDest(); + + // Number of flits is dependent on the link bandwidth available. + // This is expressed in terms of bytes/cycle or the flit size + int num_flits = (int) ceil((double) m_net_ptr->MessageSizeType_to_int( + net_msg_ptr->getMessageSize())/m_net_ptr->getNiFlitSize()); + + // loop to convert all multicast messages into unicast messages + for (int ctr = 0; ctr < dest_nodes.size(); ctr++) { + + // this will return a free output virtual channel + int vc = calculateVC(vnet); + + if (vc == -1) { + return false ; + } + MsgPtr new_msg_ptr = msg_ptr->clone(); + NodeID destID = dest_nodes[ctr]; + + Message *new_net_msg_ptr = new_msg_ptr.get(); + if (dest_nodes.size() > 1) { + NetDest personal_dest; + for (int m = 0; m < (int) MachineType_NUM; m++) { + if ((destID >= MachineType_base_number((MachineType) m)) && + destID < MachineType_base_number((MachineType) (m+1))) { + // calculating the NetDest associated with this destID + personal_dest.clear(); + personal_dest.add((MachineID) {(MachineType) m, (destID - + MachineType_base_number((MachineType) m))}); + new_net_msg_ptr->getDestination() = personal_dest; + break; + } + } + net_msg_dest.removeNetDest(personal_dest); + // removing the destination from the original message to reflect + // that a message with this particular destination has been + // flitisized and an output vc is acquired + net_msg_ptr->getDestination().removeNetDest(personal_dest); + } + + // Embed Route into the flits + // NetDest format is used by the routing table + // Custom routing algorithms just need destID + RouteInfo route; + route.vnet = vnet; + route.net_dest = new_net_msg_ptr->getDestination(); + route.src_ni = m_id; + route.src_router = m_router_id; + route.dest_ni = destID; + route.dest_router = m_net_ptr->get_router_id(destID); + + // initialize hops_traversed to -1 + // so that the first router increments it to 0 + route.hops_traversed = -1; + + m_net_ptr->increment_injected_packets(vnet); + for (int i = 0; i < num_flits; i++) { + m_net_ptr->increment_injected_flits(vnet); + flit *fl = new flit(i, vc, vnet, route, num_flits, new_msg_ptr, + curCycle()); + + fl->set_src_delay(curCycle() - ticksToCycles(msg_ptr->getTime())); + m_ni_out_vcs[vc]->insert(fl); + } + + m_ni_out_vcs_enqueue_time[vc] = curCycle(); + m_out_vc_state[vc]->setState(ACTIVE_, curCycle()); + } + return true ; +} + +// Looking for a free output vc +int +NetworkInterface::calculateVC(int vnet) +{ + for (int i = 0; i < m_vc_per_vnet; i++) { + int delta = m_vc_allocator[vnet]; + m_vc_allocator[vnet]++; + if (m_vc_allocator[vnet] == m_vc_per_vnet) + m_vc_allocator[vnet] = 0; + + if (m_out_vc_state[(vnet*m_vc_per_vnet) + delta]->isInState( + IDLE_, curCycle())) { + return ((vnet*m_vc_per_vnet) + delta); + } + } + return -1; +} + + +/** This function looks at the NI buffers + * if some buffer has flits which are ready to traverse the link in the next + * cycle, and the downstream output vc associated with this flit has buffers + * left, the link is scheduled for the next cycle + */ + +void +NetworkInterface::scheduleOutputLink() +{ + int vc = m_vc_round_robin; + m_vc_round_robin++; + if (m_vc_round_robin == m_num_vcs) + m_vc_round_robin = 0; + + for (int i = 0; i < m_num_vcs; i++) { + vc++; + if (vc == m_num_vcs) + vc = 0; + + // model buffer backpressure + if (m_ni_out_vcs[vc]->isReady(curCycle()) && + m_out_vc_state[vc]->has_credit()) { + + bool is_candidate_vc = true; + int t_vnet = get_vnet(vc); + int vc_base = t_vnet * m_vc_per_vnet; + + if (m_net_ptr->isVNetOrdered(t_vnet)) { + for (int vc_offset = 0; vc_offset < m_vc_per_vnet; + vc_offset++) { + int t_vc = vc_base + vc_offset; + if (m_ni_out_vcs[t_vc]->isReady(curCycle())) { + if (m_ni_out_vcs_enqueue_time[t_vc] < + m_ni_out_vcs_enqueue_time[vc]) { + is_candidate_vc = false; + break; + } + } + } + } + if (!is_candidate_vc) + continue; + + m_out_vc_state[vc]->decrement_credit(); + // Just removing the flit + flit *t_flit = m_ni_out_vcs[vc]->getTopFlit(); + t_flit->set_time(curCycle() + Cycles(1)); + outFlitQueue->insert(t_flit); + // schedule the out link + outNetLink->scheduleEventAbsolute(clockEdge(Cycles(1))); + + if (t_flit->get_type() == TAIL_ || + t_flit->get_type() == HEAD_TAIL_) { + m_ni_out_vcs_enqueue_time[vc] = Cycles(INFINITE_); + } + return; + } + } +} + +int +NetworkInterface::get_vnet(int vc) +{ + for (int i = 0; i < m_virtual_networks; i++) { + if (vc >= (i*m_vc_per_vnet) && vc < ((i+1)*m_vc_per_vnet)) { + return i; + } + } + fatal("Could not determine vc"); +} + + +// Wakeup the NI in the next cycle if there are waiting +// messages in the protocol buffer, or waiting flits in the +// output VC buffer +void +NetworkInterface::checkReschedule() +{ + for (const auto& it : inNode_ptr) { + if (it == nullptr) { + continue; + } + + while (it->isReady(clockEdge())) { // Is there a message waiting + scheduleEvent(Cycles(1)); + return; + } + } + + for (int vc = 0; vc < m_num_vcs; vc++) { + if (m_ni_out_vcs[vc]->isReady(curCycle() + Cycles(1))) { + scheduleEvent(Cycles(1)); + return; + } + } +} + +void +NetworkInterface::print(std::ostream& out) const +{ + out << "[Network Interface]"; +} + +uint32_t +NetworkInterface::functionalWrite(Packet *pkt) +{ + uint32_t num_functional_writes = 0; + for (unsigned int i = 0; i < m_num_vcs; ++i) { + num_functional_writes += m_ni_out_vcs[i]->functionalWrite(pkt); + } + + num_functional_writes += outFlitQueue->functionalWrite(pkt); + return num_functional_writes; +} + +NetworkInterface * +GarnetNetworkInterfaceParams::create() +{ + return new NetworkInterface(this); +} diff --git a/src/mem/ruby/network/garnet2.0/NetworkInterface.hh b/src/mem/ruby/network/garnet2.0/NetworkInterface.hh new file mode 100644 index 000000000..85e0145af --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/NetworkInterface.hh @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_NETWORK_INTERFACE_HH__ +#define __MEM_RUBY_NETWORK_GARNET_NETWORK_INTERFACE_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/CreditLink.hh" +#include "mem/ruby/network/garnet2.0/GarnetNetwork.hh" +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" +#include "mem/ruby/network/garnet2.0/OutVcState.hh" +#include "mem/ruby/slicc_interface/Message.hh" +#include "params/GarnetNetworkInterface.hh" + +class MessageBuffer; +class flitBuffer; + +class NetworkInterface : public ClockedObject, public Consumer +{ + public: + typedef GarnetNetworkInterfaceParams Params; + NetworkInterface(const Params *p); + ~NetworkInterface(); + + void init(); + + void addInPort(NetworkLink *in_link, CreditLink *credit_link); + void addOutPort(NetworkLink *out_link, CreditLink *credit_link, + SwitchID router_id); + + void wakeup(); + void addNode(std::vector<MessageBuffer *> &inNode, + std::vector<MessageBuffer *> &outNode); + + void print(std::ostream& out) const; + int get_vnet(int vc); + int get_router_id() { return m_router_id; } + void init_net_ptr(GarnetNetwork *net_ptr) { m_net_ptr = net_ptr; } + + uint32_t functionalWrite(Packet *); + + private: + GarnetNetwork *m_net_ptr; + const NodeID m_id; + const int m_virtual_networks, m_vc_per_vnet, m_num_vcs; + int m_router_id; // id of my router + std::vector<OutVcState *> m_out_vc_state; + std::vector<int> m_vc_allocator; + int m_vc_round_robin; // For round robin scheduling + flitBuffer *outFlitQueue; // For modeling link contention + flitBuffer *outCreditQueue; + + NetworkLink *inNetLink; + NetworkLink *outNetLink; + CreditLink *inCreditLink; + CreditLink *outCreditLink; + + // Input Flit Buffers + // The flit buffers which will serve the Consumer + std::vector<flitBuffer *> m_ni_out_vcs; + std::vector<Cycles> m_ni_out_vcs_enqueue_time; + + // The Message buffers that takes messages from the protocol + std::vector<MessageBuffer *> inNode_ptr; + // The Message buffers that provides messages to the protocol + std::vector<MessageBuffer *> outNode_ptr; + + bool flitisizeMessage(MsgPtr msg_ptr, int vnet); + int calculateVC(int vnet); + void scheduleOutputLink(); + void checkReschedule(); +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_NETWORK_INTERFACE_HH__ diff --git a/src/mem/ruby/network/garnet2.0/NetworkLink.cc b/src/mem/ruby/network/garnet2.0/NetworkLink.cc new file mode 100644 index 000000000..6010071f0 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/NetworkLink.cc @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" + +#include "mem/ruby/network/garnet2.0/CreditLink.hh" + +NetworkLink::NetworkLink(const Params *p) + : ClockedObject(p), Consumer(this), m_id(p->link_id), + m_type(NUM_LINK_TYPES_), + m_latency(p->link_latency), + linkBuffer(new flitBuffer()), link_consumer(nullptr), + link_srcQueue(nullptr), m_link_utilized(0), + m_vc_load(p->vcs_per_vnet * p->virt_nets) +{ +} + +NetworkLink::~NetworkLink() +{ + delete linkBuffer; +} + +void +NetworkLink::setLinkConsumer(Consumer *consumer) +{ + link_consumer = consumer; +} + +void +NetworkLink::setSourceQueue(flitBuffer *srcQueue) +{ + link_srcQueue = srcQueue; +} + +void +NetworkLink::wakeup() +{ + if (link_srcQueue->isReady(curCycle())) { + flit *t_flit = link_srcQueue->getTopFlit(); + t_flit->set_time(curCycle() + m_latency); + linkBuffer->insert(t_flit); + link_consumer->scheduleEventAbsolute(clockEdge(m_latency)); + m_link_utilized++; + m_vc_load[t_flit->get_vc()]++; + } +} + +NetworkLink * +NetworkLinkParams::create() +{ + return new NetworkLink(this); +} + +CreditLink * +CreditLinkParams::create() +{ + return new CreditLink(this); +} + +uint32_t +NetworkLink::functionalWrite(Packet *pkt) +{ + return linkBuffer->functionalWrite(pkt); +} diff --git a/src/mem/ruby/network/garnet2.0/NetworkLink.hh b/src/mem/ruby/network/garnet2.0/NetworkLink.hh new file mode 100644 index 000000000..cb69b39ad --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/NetworkLink.hh @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_NETWORK_LINK_HH__ +#define __MEM_RUBY_NETWORK_GARNET_NETWORK_LINK_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/flitBuffer.hh" +#include "params/NetworkLink.hh" +#include "sim/clocked_object.hh" + +class GarnetNetwork; + +class NetworkLink : public ClockedObject, public Consumer +{ + public: + typedef NetworkLinkParams Params; + NetworkLink(const Params *p); + ~NetworkLink(); + + void setLinkConsumer(Consumer *consumer); + void setSourceQueue(flitBuffer *srcQueue); + void setType(link_type type) { m_type = type; } + link_type getType() { return m_type; } + void print(std::ostream& out) const {} + int get_id() const { return m_id; } + void wakeup(); + + unsigned int getLinkUtilization() const { return m_link_utilized; } + const std::vector<unsigned int> & getVcLoad() const { return m_vc_load; } + + inline bool isReady(Cycles curTime) + { return linkBuffer->isReady(curTime); } + + inline flit* peekLink() { return linkBuffer->peekTopFlit(); } + inline flit* consumeLink() { return linkBuffer->getTopFlit(); } + + uint32_t functionalWrite(Packet *); + + private: + const int m_id; + link_type m_type; + const Cycles m_latency; + + flitBuffer *linkBuffer; + Consumer *link_consumer; + flitBuffer *link_srcQueue; + + // Statistical variables + unsigned int m_link_utilized; + std::vector<unsigned int> m_vc_load; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_NETWORK_LINK_HH__ diff --git a/src/mem/ruby/network/garnet2.0/OutVcState.cc b/src/mem/ruby/network/garnet2.0/OutVcState.cc new file mode 100644 index 000000000..1ad65ecd0 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/OutVcState.cc @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/OutVcState.hh" + +#include "mem/ruby/system/RubySystem.hh" + +OutVcState::OutVcState(int id, GarnetNetwork *network_ptr) + : m_time(0) +{ + m_id = id; + m_vc_state = IDLE_; + + if (network_ptr->get_vnet_type(id) == DATA_VNET_) + m_max_credit_count = network_ptr->getBuffersPerDataVC(); + else + m_max_credit_count = network_ptr->getBuffersPerCtrlVC(); + + m_credit_count = m_max_credit_count; + assert(m_credit_count >= 1); +} + +void +OutVcState::increment_credit() +{ + m_credit_count++; + assert(m_credit_count <= m_max_credit_count); +} + +void +OutVcState::decrement_credit() +{ + m_credit_count--; + assert(m_credit_count >= 0); +} diff --git a/src/mem/ruby/network/garnet2.0/OutVcState.hh b/src/mem/ruby/network/garnet2.0/OutVcState.hh new file mode 100644 index 000000000..b9c008df6 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/OutVcState.hh @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_OUTVC_STATE_HH__ +#define __MEM_RUBY_NETWORK_GARNET_OUTVC_STATE_HH__ + +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/GarnetNetwork.hh" + +class OutVcState +{ + public: + OutVcState(int id, GarnetNetwork *network_ptr); + + int get_credit_count() { return m_credit_count; } + inline bool has_credit() { return (m_credit_count > 0); } + void increment_credit(); + void decrement_credit(); + + inline bool + isInState(VC_state_type state, Cycles request_time) + { + return ((m_vc_state == state) && (request_time >= m_time) ); + } + inline void + setState(VC_state_type state, Cycles time) + { + m_vc_state = state; + m_time = time; + } + + private: + int m_id ; + Cycles m_time; + VC_state_type m_vc_state; + int m_credit_count; + int m_max_credit_count; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_OUTVC_STATE_HH__ diff --git a/src/mem/ruby/network/garnet2.0/OutputUnit.cc b/src/mem/ruby/network/garnet2.0/OutputUnit.cc new file mode 100644 index 000000000..85fef5e53 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/OutputUnit.cc @@ -0,0 +1,168 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/OutputUnit.hh" + +#include "base/stl_helpers.hh" +#include "debug/RubyNetwork.hh" +#include "mem/ruby/network/garnet2.0/Credit.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" + +using namespace std; +using m5::stl_helpers::deletePointers; + +OutputUnit::OutputUnit(int id, PortDirection direction, Router *router) + : Consumer(router) +{ + m_id = id; + m_direction = direction; + m_router = router; + m_num_vcs = m_router->get_num_vcs(); + m_vc_per_vnet = m_router->get_vc_per_vnet(); + m_out_buffer = new flitBuffer(); + + for (int i = 0; i < m_num_vcs; i++) { + m_outvc_state.push_back(new OutVcState(i, m_router->get_net_ptr())); + } +} + +OutputUnit::~OutputUnit() +{ + delete m_out_buffer; + deletePointers(m_outvc_state); +} + +void +OutputUnit::decrement_credit(int out_vc) +{ + DPRINTF(RubyNetwork, "Router %d OutputUnit %d decrementing credit for " + "outvc %d at time: %lld\n", + m_router->get_id(), m_id, out_vc, m_router->curCycle()); + + m_outvc_state[out_vc]->decrement_credit(); +} + +void +OutputUnit::increment_credit(int out_vc) +{ + DPRINTF(RubyNetwork, "Router %d OutputUnit %d incrementing credit for " + "outvc %d at time: %lld\n", + m_router->get_id(), m_id, out_vc, m_router->curCycle()); + + m_outvc_state[out_vc]->increment_credit(); +} + +// Check if the output VC (i.e., input VC at next router) +// has free credits (i..e, buffer slots). +// This is tracked by OutVcState +bool +OutputUnit::has_credit(int out_vc) +{ + assert(m_outvc_state[out_vc]->isInState(ACTIVE_, m_router->curCycle())); + return m_outvc_state[out_vc]->has_credit(); +} + + +// Check if the output port (i.e., input port at next router) has free VCs. +bool +OutputUnit::has_free_vc(int vnet) +{ + int vc_base = vnet*m_vc_per_vnet; + for (int vc = vc_base; vc < vc_base + m_vc_per_vnet; vc++) { + if (is_vc_idle(vc, m_router->curCycle())) + return true; + } + + return false; +} + +// Assign a free output VC to the winner of Switch Allocation +int +OutputUnit::select_free_vc(int vnet) +{ + int vc_base = vnet*m_vc_per_vnet; + for (int vc = vc_base; vc < vc_base + m_vc_per_vnet; vc++) { + if (is_vc_idle(vc, m_router->curCycle())) { + m_outvc_state[vc]->setState(ACTIVE_, m_router->curCycle()); + return vc; + } + } + + return -1; +} + +/* + * The wakeup function of the OutputUnit reads the credit signal from the + * downstream router for the output VC (i.e., input VC at downstream router). + * It increments the credit count in the appropriate output VC state. + * If the credit carries is_free_signal as true, + * the output VC is marked IDLE. + */ + +void +OutputUnit::wakeup() +{ + if (m_credit_link->isReady(m_router->curCycle())) { + Credit *t_credit = (Credit*) m_credit_link->consumeLink(); + increment_credit(t_credit->get_vc()); + + if (t_credit->is_free_signal()) + set_vc_state(IDLE_, t_credit->get_vc(), m_router->curCycle()); + + delete t_credit; + } +} + +flitBuffer* +OutputUnit::getOutQueue() +{ + return m_out_buffer; +} + +void +OutputUnit::set_out_link(NetworkLink *link) +{ + m_out_link = link; +} + +void +OutputUnit::set_credit_link(CreditLink *credit_link) +{ + m_credit_link = credit_link; +} + +uint32_t +OutputUnit::functionalWrite(Packet *pkt) +{ + return m_out_buffer->functionalWrite(pkt); +} diff --git a/src/mem/ruby/network/garnet2.0/OutputUnit.hh b/src/mem/ruby/network/garnet2.0/OutputUnit.hh new file mode 100644 index 000000000..7b6d5497c --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/OutputUnit.hh @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_OUTPUT_UNIT_HH__ +#define __MEM_RUBY_NETWORK_GARNET_OUTPUT_UNIT_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/CreditLink.hh" +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" +#include "mem/ruby/network/garnet2.0/OutVcState.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" +#include "mem/ruby/network/garnet2.0/flitBuffer.hh" + +class OutputUnit : public Consumer +{ + public: + OutputUnit(int id, PortDirection direction, Router *router); + ~OutputUnit(); + void set_out_link(NetworkLink *link); + void set_credit_link(CreditLink *credit_link); + void wakeup(); + flitBuffer* getOutQueue(); + void print(std::ostream& out) const {}; + void decrement_credit(int out_vc); + void increment_credit(int out_vc); + bool has_credit(int out_vc); + bool has_free_vc(int vnet); + int select_free_vc(int vnet); + + inline PortDirection get_direction() { return m_direction; } + + int + get_credit_count(int vc) + { + return m_outvc_state[vc]->get_credit_count(); + } + + inline int + get_outlink_id() + { + return m_out_link->get_id(); + } + + inline void + set_vc_state(VC_state_type state, int vc, Cycles curTime) + { + m_outvc_state[vc]->setState(state, curTime); + } + + inline bool + is_vc_idle(int vc, Cycles curTime) + { + return (m_outvc_state[vc]->isInState(IDLE_, curTime)); + } + + inline void + insert_flit(flit *t_flit) + { + m_out_buffer->insert(t_flit); + m_out_link->scheduleEventAbsolute(m_router->clockEdge(Cycles(1))); + } + + uint32_t functionalWrite(Packet *pkt); + + private: + int m_id; + PortDirection m_direction; + int m_num_vcs; + int m_vc_per_vnet; + Router *m_router; + NetworkLink *m_out_link; + CreditLink *m_credit_link; + + flitBuffer *m_out_buffer; // This is for the network link to consume + std::vector<OutVcState *> m_outvc_state; // vc state of downstream router + +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_OUTPUT_UNIT_HH__ diff --git a/src/mem/ruby/network/garnet2.0/README.txt b/src/mem/ruby/network/garnet2.0/README.txt new file mode 100644 index 000000000..817b1d48d --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/README.txt @@ -0,0 +1,71 @@ +README for Garnet2.0 +Written By: Tushar Krishna (tushar@ece.gatech.edu) +Last Updated: Jul 9, 2016 +------------------------------------------------------- + +Garnet Network Parameters and Setup: +- GarnetNetwork.py + * defaults can be overwritten from command line (see configs/network/Network.py) +- GarnetNetwork.hh/cc + * sets up the routers and links + * collects stats + + +CODE FLOW +- NetworkInterface.cc::wakeup() + * Every NI connected to one coherence protocol controller on one end, and one router on the other. + * receives messages from coherence protocol buffer in appropriate vnet and converts them into network packets and sends them into the network. + * garnet2.0 adds the ability to capture a network trace at this point. + * receives flits from the network, extracts the protocol message and sends it to the coherence protocol buffer in appropriate vnet. + * manages flow-control (i.e., credits) with its attached router. + * The consuming flit/credit output link of the NI is put in the global event queue with a timestamp set to next cycle. + The eventqueue calls the wakeup function in the consumer. + +- NetworkLink.cc::wakeup() + * receives flits from NI/router and sends it to NI/router after m_latency cycles delay + * Default latency value for every link can be set from command line (see configs/network/Network.py) + * Per link latency can be overwritten in the topology file + * The consumer of the link (NI/router) is put in the global event queue with a timestamp set after m_latency cycles. + The eventqueue calls the wakeup function in the consumer. + +- Router.cc::wakeup() + * Loop through all InputUnits and call their wakeup() + * Loop through all OutputUnits and call their wakeup() + * Call SwitchAllocator's wakeup() + * Call CrossbarSwitch's wakeup() + * The router's wakeup function is called whenever any of its modules (InputUnit, OutputUnit, SwitchAllocator, CrossbarSwitch) have + a ready flit/credit to act upon this cycle. + +- InputUnit.cc::wakeup() + * Read input flit from upstream router if it is ready for this cycle + * For HEAD/HEAD_TAIL flits, perform route computation, and update route in the VC. + * Buffer the flit for (m_latency - 1) cycles and mark it valid for SwitchAllocation starting that cycle. + * Default latency for every router can be set from command line (see configs/network/Network.py) + * Per router latency (i.e., num pipeline stages) can be set in the topology file + +- OutputUnit.cc::wakeup() + * Read input credit from downstream router if it is ready for this cycle + * Increment the credit in the appropriate output VC state. + * Mark output VC as free if the credit carries is_free_signal as true + +- SwitchAllocator.cc::wakeup() + * Note: SwitchAllocator performs VC arbitration and selection within it. + * SA-I (or SA-i): Loop through all input VCs at every input port, and select one in a round robin manner. + * For HEAD/HEAD_TAIL flits only select an input VC whose output port has at least one free output VC. + * For BODY/TAIL flits, only select an input VC that has credits in its output VC. + * Place a request for the output port from this VC. + * SA-II (or SA-o): Loop through all output ports, and select one input VC (that placed a request during SA-I) as the winner for this output port in a round robin manner. + * For HEAD/HEAD_TAIL flits, perform outvc allocation (i.e., select a free VC from the output port). + * For BODY/TAIL flits, decrement a credit in the output vc. + * Read the flit out from the input VC, and send it to the CrossbarSwitch + * Send a increment_credit signal to the upstream router for this input VC. + * for HEAD_TAIL/TAIL flits, mark is_free_signal as true in the credit. + * The input unit sends the credit out on the credit link to the upstream router. + * Reschedule the Router to wakeup next cycle for any flits ready for SA next cycle. + +- CrossbarSwitch.cc::wakeup() + * Loop through all input ports, and send the winning flit out of its output port onto the output link. + * The consuming flit output link of the router is put in the global event queue with a timestamp set to next cycle. + The eventqueue calls the wakeup function in the consumer. + + diff --git a/src/mem/ruby/network/garnet2.0/Router.cc b/src/mem/ruby/network/garnet2.0/Router.cc new file mode 100644 index 000000000..65a730096 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/Router.cc @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/Router.hh" + +#include "base/stl_helpers.hh" +#include "debug/RubyNetwork.hh" +#include "mem/ruby/network/garnet2.0/CreditLink.hh" +#include "mem/ruby/network/garnet2.0/CrossbarSwitch.hh" +#include "mem/ruby/network/garnet2.0/GarnetNetwork.hh" +#include "mem/ruby/network/garnet2.0/InputUnit.hh" +#include "mem/ruby/network/garnet2.0/NetworkLink.hh" +#include "mem/ruby/network/garnet2.0/OutputUnit.hh" +#include "mem/ruby/network/garnet2.0/RoutingUnit.hh" +#include "mem/ruby/network/garnet2.0/SwitchAllocator.hh" + +using namespace std; +using m5::stl_helpers::deletePointers; + +Router::Router(const Params *p) + : BasicRouter(p), Consumer(this) +{ + m_latency = p->latency; + m_virtual_networks = p->virt_nets; + m_vc_per_vnet = p->vcs_per_vnet; + m_num_vcs = m_virtual_networks * m_vc_per_vnet; + + m_routing_unit = new RoutingUnit(this); + m_sw_alloc = new SwitchAllocator(this); + m_switch = new CrossbarSwitch(this); + + m_input_unit.clear(); + m_output_unit.clear(); +} + +Router::~Router() +{ + deletePointers(m_input_unit); + deletePointers(m_output_unit); + delete m_routing_unit; + delete m_sw_alloc; + delete m_switch; +} + +void +Router::init() +{ + BasicRouter::init(); + + m_sw_alloc->init(); + m_switch->init(); +} + +void +Router::wakeup() +{ + DPRINTF(RubyNetwork, "Router %d woke up\n", m_id); + + // check for incoming flits + for (int inport = 0; inport < m_input_unit.size(); inport++) { + m_input_unit[inport]->wakeup(); + } + + // check for incoming credits + // Note: the credit update is happening before SA + // buffer turnaround time = + // credit traversal (1-cycle) + SA (1-cycle) + Link Traversal (1-cycle) + // if we want the credit update to take place after SA, this loop should + // be moved after the SA request + for (int outport = 0; outport < m_output_unit.size(); outport++) { + m_output_unit[outport]->wakeup(); + } + + // Switch Allocation + m_sw_alloc->wakeup(); + + // Switch Traversal + m_switch->wakeup(); +} + +void +Router::addInPort(PortDirection inport_dirn, + NetworkLink *in_link, CreditLink *credit_link) +{ + int port_num = m_input_unit.size(); + InputUnit *input_unit = new InputUnit(port_num, inport_dirn, this); + + input_unit->set_in_link(in_link); + input_unit->set_credit_link(credit_link); + in_link->setLinkConsumer(this); + credit_link->setSourceQueue(input_unit->getCreditQueue()); + + m_input_unit.push_back(input_unit); + + m_routing_unit->addInDirection(inport_dirn, port_num); +} + +void +Router::addOutPort(PortDirection outport_dirn, + NetworkLink *out_link, + const NetDest& routing_table_entry, int link_weight, + CreditLink *credit_link) +{ + int port_num = m_output_unit.size(); + OutputUnit *output_unit = new OutputUnit(port_num, outport_dirn, this); + + output_unit->set_out_link(out_link); + output_unit->set_credit_link(credit_link); + credit_link->setLinkConsumer(this); + out_link->setSourceQueue(output_unit->getOutQueue()); + + m_output_unit.push_back(output_unit); + + m_routing_unit->addRoute(routing_table_entry); + m_routing_unit->addWeight(link_weight); + m_routing_unit->addOutDirection(outport_dirn, port_num); +} + +PortDirection +Router::getOutportDirection(int outport) +{ + return m_output_unit[outport]->get_direction(); +} + +PortDirection +Router::getInportDirection(int inport) +{ + return m_input_unit[inport]->get_direction(); +} + +int +Router::route_compute(RouteInfo route, int inport, PortDirection inport_dirn) +{ + return m_routing_unit->outportCompute(route, inport, inport_dirn); +} + +void +Router::grant_switch(int inport, flit *t_flit) +{ + m_switch->update_sw_winner(inport, t_flit); +} + +void +Router::schedule_wakeup(Cycles time) +{ + // wake up after time cycles + scheduleEvent(time); +} + +std::string +Router::getPortDirectionName(PortDirection direction) +{ + // PortDirection is actually a string + // If not, then this function should add a switch + // statement to convert direction to a string + // that can be printed out + return direction; +} + +void +Router::regStats() +{ + BasicRouter::regStats(); + + m_buffer_reads + .name(name() + ".buffer_reads") + .flags(Stats::nozero) + ; + + m_buffer_writes + .name(name() + ".buffer_writes") + .flags(Stats::nozero) + ; + + m_crossbar_activity + .name(name() + ".crossbar_activity") + .flags(Stats::nozero) + ; + + m_sw_input_arbiter_activity + .name(name() + ".sw_input_arbiter_activity") + .flags(Stats::nozero) + ; + + m_sw_output_arbiter_activity + .name(name() + ".sw_output_arbiter_activity") + .flags(Stats::nozero) + ; +} + +void +Router::collateStats() +{ + for (int j = 0; j < m_virtual_networks; j++) { + for (int i = 0; i < m_input_unit.size(); i++) { + m_buffer_reads += m_input_unit[i]->get_buf_read_activity(j); + m_buffer_writes += m_input_unit[i]->get_buf_write_activity(j); + } + } + + m_sw_input_arbiter_activity = m_sw_alloc->get_input_arbiter_activity(); + m_sw_output_arbiter_activity = m_sw_alloc->get_output_arbiter_activity(); + m_crossbar_activity = m_switch->get_crossbar_activity(); +} + +void +Router::resetStats() +{ + for (int j = 0; j < m_virtual_networks; j++) { + for (int i = 0; i < m_input_unit.size(); i++) { + m_input_unit[i]->resetStats(); + } + } +} + +void +Router::printFaultVector(ostream& out) +{ + int temperature_celcius = BASELINE_TEMPERATURE_CELCIUS; + int num_fault_types = m_network_ptr->fault_model->number_of_fault_types; + float fault_vector[num_fault_types]; + get_fault_vector(temperature_celcius, fault_vector); + out << "Router-" << m_id << " fault vector: " << endl; + for (int fault_type_index = 0; fault_type_index < num_fault_types; + fault_type_index++) { + out << " - probability of ("; + out << + m_network_ptr->fault_model->fault_type_to_string(fault_type_index); + out << ") = "; + out << fault_vector[fault_type_index] << endl; + } +} + +void +Router::printAggregateFaultProbability(std::ostream& out) +{ + int temperature_celcius = BASELINE_TEMPERATURE_CELCIUS; + float aggregate_fault_prob; + get_aggregate_fault_probability(temperature_celcius, + &aggregate_fault_prob); + out << "Router-" << m_id << " fault probability: "; + out << aggregate_fault_prob << endl; +} + +uint32_t +Router::functionalWrite(Packet *pkt) +{ + uint32_t num_functional_writes = 0; + num_functional_writes += m_switch->functionalWrite(pkt); + + for (uint32_t i = 0; i < m_input_unit.size(); i++) { + num_functional_writes += m_input_unit[i]->functionalWrite(pkt); + } + + for (uint32_t i = 0; i < m_output_unit.size(); i++) { + num_functional_writes += m_output_unit[i]->functionalWrite(pkt); + } + + return num_functional_writes; +} + +Router * +GarnetRouterParams::create() +{ + return new Router(this); +} diff --git a/src/mem/ruby/network/garnet2.0/Router.hh b/src/mem/ruby/network/garnet2.0/Router.hh new file mode 100644 index 000000000..a9ce5f80e --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/Router.hh @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_ROUTER_HH__ +#define __MEM_RUBY_NETWORK_GARNET_ROUTER_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/common/NetDest.hh" +#include "mem/ruby/network/BasicRouter.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/GarnetNetwork.hh" +#include "mem/ruby/network/garnet2.0/flit.hh" +#include "params/GarnetRouter.hh" + +class NetworkLink; +class CreditLink; +class InputUnit; +class OutputUnit; +class RoutingUnit; +class SwitchAllocator; +class CrossbarSwitch; +class FaultModel; + +class Router : public BasicRouter, public Consumer +{ + public: + typedef GarnetRouterParams Params; + Router(const Params *p); + + ~Router(); + + void wakeup(); + void print(std::ostream& out) const {}; + + void init(); + void addInPort(PortDirection inport_dirn, NetworkLink *link, + CreditLink *credit_link); + void addOutPort(PortDirection outport_dirn, NetworkLink *link, + const NetDest& routing_table_entry, + int link_weight, CreditLink *credit_link); + + Cycles get_pipe_stages(){ return m_latency; } + int get_num_vcs() { return m_num_vcs; } + int get_num_vnets() { return m_virtual_networks; } + int get_vc_per_vnet() { return m_vc_per_vnet; } + int get_num_inports() { return m_input_unit.size(); } + int get_num_outports() { return m_output_unit.size(); } + int get_id() { return m_id; } + + void init_net_ptr(GarnetNetwork* net_ptr) + { + m_network_ptr = net_ptr; + } + + GarnetNetwork* get_net_ptr() { return m_network_ptr; } + std::vector<InputUnit *>& get_inputUnit_ref() { return m_input_unit; } + std::vector<OutputUnit *>& get_outputUnit_ref() { return m_output_unit; } + PortDirection getOutportDirection(int outport); + PortDirection getInportDirection(int inport); + + int route_compute(RouteInfo route, int inport, PortDirection direction); + void grant_switch(int inport, flit *t_flit); + void schedule_wakeup(Cycles time); + + std::string getPortDirectionName(PortDirection direction); + void printFaultVector(std::ostream& out); + void printAggregateFaultProbability(std::ostream& out); + + void regStats(); + void collateStats(); + void resetStats(); + + // For Fault Model: + bool get_fault_vector(int temperature, float fault_vector[]) { + return m_network_ptr->fault_model->fault_vector(m_id, temperature, + fault_vector); + } + bool get_aggregate_fault_probability(int temperature, + float *aggregate_fault_prob) { + return m_network_ptr->fault_model->fault_prob(m_id, temperature, + aggregate_fault_prob); + } + + uint32_t functionalWrite(Packet *); + + private: + Cycles m_latency; + int m_virtual_networks, m_num_vcs, m_vc_per_vnet; + GarnetNetwork *m_network_ptr; + + std::vector<InputUnit *> m_input_unit; + std::vector<OutputUnit *> m_output_unit; + RoutingUnit *m_routing_unit; + SwitchAllocator *m_sw_alloc; + CrossbarSwitch *m_switch; + + // Statistical variables required for power computations + Stats::Scalar m_buffer_reads; + Stats::Scalar m_buffer_writes; + + Stats::Scalar m_sw_input_arbiter_activity; + Stats::Scalar m_sw_output_arbiter_activity; + + Stats::Scalar m_crossbar_activity; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_ROUTER_HH__ diff --git a/src/mem/ruby/network/garnet2.0/RoutingUnit.cc b/src/mem/ruby/network/garnet2.0/RoutingUnit.cc new file mode 100644 index 000000000..aa5ff53c1 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/RoutingUnit.cc @@ -0,0 +1,241 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/RoutingUnit.hh" + +#include "base/cast.hh" +#include "mem/ruby/network/garnet2.0/InputUnit.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" +#include "mem/ruby/slicc_interface/Message.hh" + +RoutingUnit::RoutingUnit(Router *router) +{ + m_router = router; + m_routing_table.clear(); + m_weight_table.clear(); +} + +void +RoutingUnit::addRoute(const NetDest& routing_table_entry) +{ + m_routing_table.push_back(routing_table_entry); +} + +void +RoutingUnit::addWeight(int link_weight) +{ + m_weight_table.push_back(link_weight); +} + +/* + * This is the default routing algorithm in garnet. + * The routing table is populated during topology creation. + * Routes can be biased via weight assignments in the topology file. + * Correct weight assignments are critical to provide deadlock avoidance. + */ + +int +RoutingUnit::lookupRoutingTable(int vnet, NetDest msg_destination) +{ + // First find all possible output link candidates + // For ordered vnet, just choose the first + // (to make sure different packets don't choose different routes) + // For unordered vnet, randomly choose any of the links + // To have a strict ordering between links, they should be given + // different weights in the topology file + + int output_link = -1; + int min_weight = INFINITE_; + std::vector<int> output_link_candidates; + int num_candidates = 0; + + // Identify the minimum weight among the candidate output links + for (int link = 0; link < m_routing_table.size(); link++) { + if (msg_destination.intersectionIsNotEmpty(m_routing_table[link])) { + + if (m_weight_table[link] <= min_weight) + min_weight = m_weight_table[link]; + } + } + + // Collect all candidate output links with this minimum weight + for (int link = 0; link < m_routing_table.size(); link++) { + if (msg_destination.intersectionIsNotEmpty(m_routing_table[link])) { + + if (m_weight_table[link] == min_weight) { + + num_candidates++; + output_link_candidates.push_back(link); + } + } + } + + if (output_link_candidates.size() == 0) { + fatal("Fatal Error:: No Route exists from this Router."); + exit(0); + } + + // Randomly select any candidate output link + int candidate = 0; + if (!(m_router->get_net_ptr())->isVNetOrdered(vnet)) + candidate = rand() % num_candidates; + + output_link = output_link_candidates.at(candidate); + return output_link; +} + + +void +RoutingUnit::addInDirection(PortDirection inport_dirn, int inport_idx) +{ + m_inports_dirn2idx[inport_dirn] = inport_idx; + m_inports_idx2dirn[inport_idx] = inport_dirn; +} + +void +RoutingUnit::addOutDirection(PortDirection outport_dirn, int outport_idx) +{ + m_outports_dirn2idx[outport_dirn] = outport_idx; + m_outports_idx2dirn[outport_idx] = outport_dirn; +} + +// outportCompute() is called by the InputUnit +// It calls the routing table by default. +// A template for adaptive topology-specific routing algorithm +// implementations using port directions rather than a static routing +// table is provided here. + +int +RoutingUnit::outportCompute(RouteInfo route, int inport, + PortDirection inport_dirn) +{ + int outport = -1; + + if (route.dest_router == m_router->get_id()) { + + // Multiple NIs may be connected to this router, + // all with output port direction = "Local" + // Get exact outport id from table + outport = lookupRoutingTable(route.vnet, route.net_dest); + return outport; + } + + // Routing Algorithm set in GarnetNetwork.py + // Can be over-ridden from command line using --routing-algorithm = 1 + RoutingAlgorithm routing_algorithm = + (RoutingAlgorithm) m_router->get_net_ptr()->getRoutingAlgorithm(); + + switch (routing_algorithm) { + case TABLE_: outport = + lookupRoutingTable(route.vnet, route.net_dest); break; + case XY_: outport = + outportComputeXY(route, inport, inport_dirn); break; + // any custom algorithm + case CUSTOM_: outport = + outportComputeCustom(route, inport, inport_dirn); break; + default: outport = + lookupRoutingTable(route.vnet, route.net_dest); break; + } + + assert(outport != -1); + return outport; +} + +// XY routing implemented using port directions +// Only for reference purpose in a Mesh +// By default Garnet uses the routing table +int +RoutingUnit::outportComputeXY(RouteInfo route, + int inport, + PortDirection inport_dirn) +{ + PortDirection outport_dirn = "Unknown"; + + int num_rows = m_router->get_net_ptr()->getNumRows(); + int num_cols = m_router->get_net_ptr()->getNumCols(); + assert(num_rows > 0 && num_cols > 0); + + int my_id = m_router->get_id(); + int my_x = my_id % num_cols; + int my_y = my_id / num_cols; + + int dest_id = route.dest_router; + int dest_x = dest_id % num_cols; + int dest_y = dest_id / num_cols; + + int x_hops = abs(dest_x - my_x); + int y_hops = abs(dest_y - my_y); + + bool x_dirn = (dest_x >= my_x); + bool y_dirn = (dest_y >= my_y); + + // already checked that in outportCompute() function + assert(!(x_hops == 0 && y_hops == 0)); + + if (x_hops > 0) { + if (x_dirn) { + assert(inport_dirn == "Local" || inport_dirn == "West"); + outport_dirn = "East"; + } else { + assert(inport_dirn == "Local" || inport_dirn == "East"); + outport_dirn = "West"; + } + } else if (y_hops > 0) { + if (y_dirn) { + // "Local" or "South" or "West" or "East" + assert(inport_dirn != "North"); + outport_dirn = "North"; + } else { + // "Local" or "North" or "West" or "East" + assert(inport_dirn != "South"); + outport_dirn = "South"; + } + } else { + // x_hops == 0 and y_hops == 0 + // this is not possible + // already checked that in outportCompute() function + assert(0); + } + + return m_outports_dirn2idx[outport_dirn]; +} + +// Template for implementing custom routing algorithm +// using port directions. (Example adaptive) +int +RoutingUnit::outportComputeCustom(RouteInfo route, + int inport, + PortDirection inport_dirn) +{ + assert(0); +} diff --git a/src/mem/ruby/network/garnet2.0/RoutingUnit.hh b/src/mem/ruby/network/garnet2.0/RoutingUnit.hh new file mode 100644 index 000000000..46b0969f3 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/RoutingUnit.hh @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_ROUTING_UNIT_HH__ +#define __MEM_RUBY_NETWORK_GARNET_ROUTING_UNIT_HH__ + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/common/NetDest.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/GarnetNetwork.hh" +#include "mem/ruby/network/garnet2.0/flit.hh" + +class InputUnit; +class Router; + +class RoutingUnit +{ + public: + RoutingUnit(Router *router); + int outportCompute(RouteInfo route, + int inport, + PortDirection inport_dirn); + + // Topology-agnostic Routing Table based routing (default) + void addRoute(const NetDest& routing_table_entry); + void addWeight(int link_weight); + + // get output port from routing table + int lookupRoutingTable(int vnet, NetDest net_dest); + + // Topology-specific direction based routing + void addInDirection(PortDirection inport_dirn, int inport); + void addOutDirection(PortDirection outport_dirn, int outport); + + // Routing for Mesh + int outportComputeXY(RouteInfo route, + int inport, + PortDirection inport_dirn); + + // Custom Routing Algorithm using Port Directions + int outportComputeCustom(RouteInfo route, + int inport, + PortDirection inport_dirn); + + private: + Router *m_router; + + // Routing Table + std::vector<NetDest> m_routing_table; + std::vector<int> m_weight_table; + + // Inport and Outport direction to idx maps + std::map<PortDirection, int> m_inports_dirn2idx; + std::map<int, PortDirection> m_inports_idx2dirn; + std::map<int, PortDirection> m_outports_idx2dirn; + std::map<PortDirection, int> m_outports_dirn2idx; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_ROUTING_UNIT_HH__ diff --git a/src/mem/ruby/network/garnet2.0/SConscript b/src/mem/ruby/network/garnet2.0/SConscript new file mode 100644 index 000000000..866bab9ac --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/SConscript @@ -0,0 +1,53 @@ +# -*- mode:python -*- + +# Copyright (c) 2016 Georgia Institute of Technology +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# Authors: Tushar Krishna + +Import('*') + +if env['PROTOCOL'] == 'None': + Return() + +SimObject('GarnetLink.py') +SimObject('GarnetNetwork.py') + +Source('GarnetLink.cc') +Source('GarnetNetwork.cc') +Source('InputUnit.cc') +Source('NetworkInterface.cc') +Source('NetworkLink.cc') +Source('OutVcState.cc') +Source('OutputUnit.cc') +Source('Router.cc') +Source('RoutingUnit.cc') +Source('SwitchAllocator.cc') +Source('CrossbarSwitch.cc') +Source('VirtualChannel.cc') +Source('flitBuffer.cc') +Source('flit.cc') +Source('Credit.cc') diff --git a/src/mem/ruby/network/garnet2.0/SwitchAllocator.cc b/src/mem/ruby/network/garnet2.0/SwitchAllocator.cc new file mode 100644 index 000000000..7916802a5 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/SwitchAllocator.cc @@ -0,0 +1,389 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/SwitchAllocator.hh" + +#include "debug/RubyNetwork.hh" +#include "mem/ruby/network/garnet2.0/GarnetNetwork.hh" +#include "mem/ruby/network/garnet2.0/InputUnit.hh" +#include "mem/ruby/network/garnet2.0/OutputUnit.hh" +#include "mem/ruby/network/garnet2.0/Router.hh" + +SwitchAllocator::SwitchAllocator(Router *router) + : Consumer(router) +{ + m_router = router; + m_num_vcs = m_router->get_num_vcs(); + m_vc_per_vnet = m_router->get_vc_per_vnet(); + + m_input_arbiter_activity = 0; + m_output_arbiter_activity = 0; +} + +void +SwitchAllocator::init() +{ + m_input_unit = m_router->get_inputUnit_ref(); + m_output_unit = m_router->get_outputUnit_ref(); + + m_num_inports = m_router->get_num_inports(); + m_num_outports = m_router->get_num_outports(); + m_round_robin_inport.resize(m_num_outports); + m_round_robin_invc.resize(m_num_inports); + m_port_requests.resize(m_num_outports); + m_vc_winners.resize(m_num_outports); + + for (int i = 0; i < m_num_inports; i++) { + m_round_robin_invc[i] = 0; + } + + for (int i = 0; i < m_num_outports; i++) { + m_port_requests[i].resize(m_num_inports); + m_vc_winners[i].resize(m_num_inports); + + m_round_robin_inport[i] = 0; + + for (int j = 0; j < m_num_inports; j++) { + m_port_requests[i][j] = false; // [outport][inport] + } + } +} + +/* + * The wakeup function of the SwitchAllocator performs a 2-stage + * seperable switch allocation. At the end of the 2nd stage, a free + * output VC is assigned to the winning flits of each output port. + * There is no separate VCAllocator stage like the one in garnet1.0. + * At the end of this function, the router is rescheduled to wakeup + * next cycle for peforming SA for any flits ready next cycle. + */ + +void +SwitchAllocator::wakeup() +{ + arbitrate_inports(); // First stage of allocation + arbitrate_outports(); // Second stage of allocation + + clear_request_vector(); + check_for_wakeup(); +} + +/* + * SA-I (or SA-i) loops through all input VCs at every input port, + * and selects one in a round robin manner. + * - For HEAD/HEAD_TAIL flits only selects an input VC whose output port + * has at least one free output VC. + * - For BODY/TAIL flits, only selects an input VC that has credits + * in its output VC. + * Places a request for the output port from this input VC. + */ + +void +SwitchAllocator::arbitrate_inports() +{ + // Select a VC from each input in a round robin manner + // Independent arbiter at each input port + for (int inport = 0; inport < m_num_inports; inport++) { + int invc = m_round_robin_invc[inport]; + + // Select next round robin vc candidate within valid vnet + int next_round_robin_invc = invc; + next_round_robin_invc++; + if (next_round_robin_invc >= m_num_vcs) + next_round_robin_invc = 0; + m_round_robin_invc[inport] = next_round_robin_invc; + + for (int invc_iter = 0; invc_iter < m_num_vcs; invc_iter++) { + + if (m_input_unit[inport]->need_stage(invc, SA_, + m_router->curCycle())) { + + // This flit is in SA stage + + int outport = m_input_unit[inport]->get_outport(invc); + int outvc = m_input_unit[inport]->get_outvc(invc); + + // check if the flit in this InputVC is allowed to be sent + // send_allowed conditions described in that function. + bool make_request = + send_allowed(inport, invc, outport, outvc); + + if (make_request) { + m_input_arbiter_activity++; + m_port_requests[outport][inport] = true; + m_vc_winners[outport][inport]= invc; + break; // got one vc winner for this port + } + } + + invc++; + if (invc >= m_num_vcs) + invc = 0; + } + } +} + +/* + * SA-II (or SA-o) loops through all output ports, + * and selects one input VC (that placed a request during SA-I) + * as the winner for this output port in a round robin manner. + * - For HEAD/HEAD_TAIL flits, performs simplified outvc allocation. + * (i.e., select a free VC from the output port). + * - For BODY/TAIL flits, decrement a credit in the output vc. + * The winning flit is read out from the input VC and sent to the + * CrossbarSwitch. + * An increment_credit signal is sent from the InputUnit + * to the upstream router. For HEAD_TAIL/TAIL flits, is_free_signal in the + * credit is set to true. + */ + +void +SwitchAllocator::arbitrate_outports() +{ + // Now there are a set of input vc requests for output vcs. + // Again do round robin arbitration on these requests + // Independent arbiter at each output port + for (int outport = 0; outport < m_num_outports; outport++) { + int inport = m_round_robin_inport[outport]; + m_round_robin_inport[outport]++; + + if (m_round_robin_inport[outport] >= m_num_inports) + m_round_robin_inport[outport] = 0; + + for (int inport_iter = 0; inport_iter < m_num_inports; + inport_iter++) { + + // inport has a request this cycle for outport + if (m_port_requests[outport][inport]) { + + // grant this outport to this inport + int invc = m_vc_winners[outport][inport]; + + int outvc = m_input_unit[inport]->get_outvc(invc); + if (outvc == -1) { + // VC Allocation - select any free VC from outport + outvc = vc_allocate(outport, inport, invc); + } + + // remove flit from Input VC + flit *t_flit = m_input_unit[inport]->getTopFlit(invc); + + DPRINTF(RubyNetwork, "SwitchAllocator at Router %d " + "granted outvc %d at outport %d " + "to invc %d at inport %d to flit %s at " + "time: %lld\n", + m_router->get_id(), outvc, + m_router->getPortDirectionName( + m_output_unit[outport]->get_direction()), + invc, + m_router->getPortDirectionName( + m_input_unit[inport]->get_direction()), + *t_flit, + m_router->curCycle()); + + + // Update outport field in the flit since this is + // used by CrossbarSwitch code to send it out of + // correct outport. + // Note: post route compute in InputUnit, + // outport is updated in VC, but not in flit + t_flit->set_outport(outport); + + // set outvc (i.e., invc for next hop) in flit + // (This was updated in VC by vc_allocate, but not in flit) + t_flit->set_vc(outvc); + + // decrement credit in outvc + m_output_unit[outport]->decrement_credit(outvc); + + // flit ready for Switch Traversal + t_flit->advance_stage(ST_, m_router->curCycle()); + m_router->grant_switch(inport, t_flit); + m_output_arbiter_activity++; + + if ((t_flit->get_type() == TAIL_) || + t_flit->get_type() == HEAD_TAIL_) { + + // This Input VC should now be empty + assert(!(m_input_unit[inport]->isReady(invc, + m_router->curCycle()))); + + // Free this VC + m_input_unit[inport]->set_vc_idle(invc, + m_router->curCycle()); + + // Send a credit back + // along with the information that this VC is now idle + m_input_unit[inport]->increment_credit(invc, true, + m_router->curCycle()); + } else { + // Send a credit back + // but do not indicate that the VC is idle + m_input_unit[inport]->increment_credit(invc, false, + m_router->curCycle()); + } + + // remove this request + m_port_requests[outport][inport] = false; + + break; // got a input winner for this outport + } + + inport++; + if (inport >= m_num_inports) + inport = 0; + } + } +} + +/* + * A flit can be sent only if + * (1) there is at least one free output VC at the + * output port (for HEAD/HEAD_TAIL), + * or + * (2) if there is at least one credit (i.e., buffer slot) + * within the VC for BODY/TAIL flits of multi-flit packets. + * and + * (3) pt-to-pt ordering is not violated in ordered vnets, i.e., + * there should be no other flit in this input port + * within an ordered vnet + * that arrived before this flit and is requesting the same output port. + */ + +bool +SwitchAllocator::send_allowed(int inport, int invc, int outport, int outvc) +{ + // Check if outvc needed + // Check if credit needed (for multi-flit packet) + // Check if ordering violated (in ordered vnet) + + int vnet = get_vnet(invc); + bool has_outvc = (outvc != -1); + bool has_credit = false; + + if (!has_outvc) { + + // needs outvc + // this is only true for HEAD and HEAD_TAIL flits. + + if (m_output_unit[outport]->has_free_vc(vnet)) { + + has_outvc = true; + + // each VC has at least one buffer, + // so no need for additional credit check + has_credit = true; + } + } else { + has_credit = m_output_unit[outport]->has_credit(outvc); + } + + // cannot send if no outvc or no credit. + if (!has_outvc || !has_credit) + return false; + + + // protocol ordering check + if ((m_router->get_net_ptr())->isVNetOrdered(vnet)) { + + // enqueue time of this flit + Cycles t_enqueue_time = m_input_unit[inport]->get_enqueue_time(invc); + + // check if any other flit is ready for SA and for same output port + // and was enqueued before this flit + int vc_base = vnet*m_vc_per_vnet; + for (int vc_offset = 0; vc_offset < m_vc_per_vnet; vc_offset++) { + int temp_vc = vc_base + vc_offset; + if (m_input_unit[inport]->need_stage(temp_vc, SA_, + m_router->curCycle()) && + (m_input_unit[inport]->get_outport(temp_vc) == outport) && + (m_input_unit[inport]->get_enqueue_time(temp_vc) < + t_enqueue_time)) { + return false; + } + } + } + + return true; +} + +// Assign a free VC to the winner of the output port. +int +SwitchAllocator::vc_allocate(int outport, int inport, int invc) +{ + // Select a free VC from the output port + int outvc = m_output_unit[outport]->select_free_vc(get_vnet(invc)); + + // has to get a valid VC since it checked before performing SA + assert(outvc != -1); + m_input_unit[inport]->grant_outvc(invc, outvc); + return outvc; +} + +// Wakeup the router next cycle to perform SA again +// if there are flits ready. +void +SwitchAllocator::check_for_wakeup() +{ + Cycles nextCycle = m_router->curCycle() + Cycles(1); + + for (int i = 0; i < m_num_inports; i++) { + for (int j = 0; j < m_num_vcs; j++) { + if (m_input_unit[i]->need_stage(j, SA_, nextCycle)) { + m_router->schedule_wakeup(Cycles(1)); + return; + } + } + } +} + +int +SwitchAllocator::get_vnet(int invc) +{ + int vnet = invc/m_vc_per_vnet; + assert(vnet < m_router->get_num_vnets()); + return vnet; +} + + +// Clear the request vector within the allocator at end of SA-II. +// Was populated by SA-I. +void +SwitchAllocator::clear_request_vector() +{ + for (int i = 0; i < m_num_outports; i++) { + for (int j = 0; j < m_num_inports; j++) { + m_port_requests[i][j] = false; + } + } +} diff --git a/src/mem/ruby/network/garnet2.0/SwitchAllocator.hh b/src/mem/ruby/network/garnet2.0/SwitchAllocator.hh new file mode 100644 index 000000000..162264e85 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/SwitchAllocator.hh @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_SWITCH_ALLOCATOR_HH__ +#define __MEM_RUBY_NETWORK_GARNET_SWITCH_ALLOCATOR_HH__ + +#include <iostream> +#include <vector> + +#include "mem/ruby/common/Consumer.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" + +class Router; +class InputUnit; +class OutputUnit; + +class SwitchAllocator : public Consumer +{ + public: + SwitchAllocator(Router *router); + void wakeup(); + void init(); + void clear_request_vector(); + void check_for_wakeup(); + int get_vnet (int invc); + void print(std::ostream& out) const {}; + void arbitrate_inports(); + void arbitrate_outports(); + bool send_allowed(int inport, int invc, int outport, int outvc); + int vc_allocate(int outport, int inport, int invc); + + inline double + get_input_arbiter_activity() + { + return m_input_arbiter_activity; + } + inline double + get_output_arbiter_activity() + { + return m_output_arbiter_activity; + } + + private: + int m_num_inports, m_num_outports; + int m_num_vcs, m_vc_per_vnet; + + double m_input_arbiter_activity, m_output_arbiter_activity; + + Router *m_router; + std::vector<int> m_round_robin_invc; + std::vector<int> m_round_robin_inport; + std::vector<std::vector<bool>> m_port_requests; + std::vector<std::vector<int>> m_vc_winners; // a list for each outport + std::vector<InputUnit *> m_input_unit; + std::vector<OutputUnit *> m_output_unit; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_SWITCH_ALLOCATOR_HH__ diff --git a/src/mem/ruby/network/garnet2.0/VirtualChannel.cc b/src/mem/ruby/network/garnet2.0/VirtualChannel.cc new file mode 100644 index 000000000..55f2a874c --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/VirtualChannel.cc @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/VirtualChannel.hh" + +VirtualChannel::VirtualChannel(int id) + : m_enqueue_time(INFINITE_) +{ + m_id = id; + m_input_buffer = new flitBuffer(); + m_vc_state.first = IDLE_; + m_vc_state.second = Cycles(0); + m_output_vc = -1; + m_output_port = -1; +} + +VirtualChannel::~VirtualChannel() +{ + delete m_input_buffer; +} + +void +VirtualChannel::set_idle(Cycles curTime) +{ + m_vc_state.first = IDLE_; + m_vc_state.second = curTime; + m_enqueue_time = Cycles(INFINITE_); + m_output_port = -1; + m_output_vc = -1; +} + +void +VirtualChannel::set_active(Cycles curTime) +{ + m_vc_state.first = ACTIVE_; + m_vc_state.second = curTime; + m_enqueue_time = curTime; +} + +bool +VirtualChannel::need_stage(flit_stage stage, Cycles time) +{ + if (m_input_buffer->isReady(time)) { + assert(m_vc_state.first == ACTIVE_ && m_vc_state.second <= time); + flit *t_flit = m_input_buffer->peekTopFlit(); + return(t_flit->is_stage(stage, time)); + } + return false; +} + +uint32_t +VirtualChannel::functionalWrite(Packet *pkt) +{ + return m_input_buffer->functionalWrite(pkt); +} diff --git a/src/mem/ruby/network/garnet2.0/VirtualChannel.hh b/src/mem/ruby/network/garnet2.0/VirtualChannel.hh new file mode 100644 index 000000000..d5f7687dc --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/VirtualChannel.hh @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_VIRTUAL_CHANNEL_HH__ +#define __MEM_RUBY_NETWORK_GARNET_VIRTUAL_CHANNEL_HH__ + +#include <utility> + +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/flitBuffer.hh" + +class VirtualChannel +{ + public: + VirtualChannel(int id); + ~VirtualChannel(); + + bool need_stage(flit_stage stage, Cycles time); + void set_idle(Cycles curTime); + void set_active(Cycles curTime); + void set_outvc(int outvc) { m_output_vc = outvc; } + inline int get_outvc() { return m_output_vc; } + void set_outport(int outport) { m_output_port = outport; }; + inline int get_outport() { return m_output_port; } + + inline Cycles get_enqueue_time() { return m_enqueue_time; } + inline void set_enqueue_time(Cycles time) { m_enqueue_time = time; } + inline VC_state_type get_state() { return m_vc_state.first; } + + inline bool isReady(Cycles curTime) + { + return m_input_buffer->isReady(curTime); + } + + inline void + insertFlit(flit *t_flit) + { + m_input_buffer->insert(t_flit); + } + + inline void + set_state(VC_state_type m_state, Cycles curTime) + { + m_vc_state.first = m_state; + m_vc_state.second = curTime; + } + + inline flit* + peekTopFlit() + { + return m_input_buffer->peekTopFlit(); + } + + inline flit* + getTopFlit() + { + return m_input_buffer->getTopFlit(); + } + + uint32_t functionalWrite(Packet *pkt); + + private: + int m_id; + flitBuffer *m_input_buffer; + std::pair<VC_state_type, Cycles> m_vc_state; + int m_output_port; + Cycles m_enqueue_time; + int m_output_vc; +}; + +#endif // __MEM_RUBY_NETWORK_GARNET_VIRTUAL_CHANNEL_HH__ diff --git a/src/mem/ruby/network/garnet2.0/flit.cc b/src/mem/ruby/network/garnet2.0/flit.cc new file mode 100644 index 000000000..e507ea442 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/flit.cc @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/flit.hh" + +// Constructor for the flit +flit::flit(int id, int vc, int vnet, RouteInfo route, int size, + MsgPtr msg_ptr, Cycles curTime) +{ + m_size = size; + m_msg_ptr = msg_ptr; + m_enqueue_time = curTime; + m_time = curTime; + m_id = id; + m_vnet = vnet; + m_vc = vc; + m_route = route; + m_stage.first = I_; + m_stage.second = m_time; + + if (size == 1) { + m_type = HEAD_TAIL_; + return; + } + if (id == 0) + m_type = HEAD_; + else if (id == (size - 1)) + m_type = TAIL_; + else + m_type = BODY_; +} + +// Flit can be printed out for debugging purposes +void +flit::print(std::ostream& out) const +{ + out << "[flit:: "; + out << "Id=" << m_id << " "; + out << "Type=" << m_type << " "; + out << "Vnet=" << m_vnet << " "; + out << "VC=" << m_vc << " "; + out << "Src NI=" << m_route.src_ni << " "; + out << "Src Router=" << m_route.src_router << " "; + out << "Dest NI=" << m_route.dest_ni << " "; + out << "Dest Router=" << m_route.dest_router << " "; + out << "Enqueue Time=" << m_enqueue_time << " "; + out << "]"; +} + +bool +flit::functionalWrite(Packet *pkt) +{ + Message *msg = m_msg_ptr.get(); + return msg->functionalWrite(pkt); +} diff --git a/src/mem/ruby/network/garnet2.0/flit.hh b/src/mem/ruby/network/garnet2.0/flit.hh new file mode 100644 index 000000000..3e30ec98c --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/flit.hh @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_FLIT_HH__ +#define __MEM_RUBY_NETWORK_GARNET_FLIT_HH__ + +#include <cassert> +#include <iostream> + +#include "base/types.hh" +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/slicc_interface/Message.hh" + +class flit +{ + public: + flit() {} + flit(int id, int vc, int vnet, RouteInfo route, int size, + MsgPtr msg_ptr, Cycles curTime); + + int get_outport() {return m_outport; } + int get_size() { return m_size; } + Cycles get_enqueue_time() { return m_enqueue_time; } + int get_id() { return m_id; } + Cycles get_time() { return m_time; } + int get_vnet() { return m_vnet; } + int get_vc() { return m_vc; } + RouteInfo get_route() { return m_route; } + MsgPtr& get_msg_ptr() { return m_msg_ptr; } + flit_type get_type() { return m_type; } + std::pair<flit_stage, Cycles> get_stage() { return m_stage; } + Cycles get_src_delay() { return src_delay; } + + void set_outport(int port) { m_outport = port; } + void set_time(Cycles time) { m_time = time; } + void set_vc(int vc) { m_vc = vc; } + void set_route(RouteInfo route) { m_route = route; } + void set_src_delay(Cycles delay) { src_delay = delay; } + + void increment_hops() { m_route.hops_traversed++; } + void print(std::ostream& out) const; + + bool + is_stage(flit_stage stage, Cycles time) + { + return (stage == m_stage.first && + time >= m_stage.second); + } + + void + advance_stage(flit_stage t_stage, Cycles newTime) + { + m_stage.first = t_stage; + m_stage.second = newTime; + } + + static bool + greater(flit* n1, flit* n2) + { + if (n1->get_time() == n2->get_time()) { + //assert(n1->flit_id != n2->flit_id); + return (n1->get_id() > n2->get_id()); + } else { + return (n1->get_time() > n2->get_time()); + } + } + + bool functionalWrite(Packet *pkt); + + protected: + int m_id; + int m_vnet; + int m_vc; + RouteInfo m_route; + int m_size; + Cycles m_enqueue_time, m_time; + flit_type m_type; + MsgPtr m_msg_ptr; + int m_outport; + Cycles src_delay; + std::pair<flit_stage, Cycles> m_stage; +}; + +inline std::ostream& +operator<<(std::ostream& out, const flit& obj) +{ + obj.print(out); + out << std::flush; + return out; +} + +#endif // __MEM_RUBY_NETWORK_GARNET_FLIT_HH__ diff --git a/src/mem/ruby/network/garnet2.0/flitBuffer.cc b/src/mem/ruby/network/garnet2.0/flitBuffer.cc new file mode 100644 index 000000000..1a089936e --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/flitBuffer.cc @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#include "mem/ruby/network/garnet2.0/flitBuffer.hh" + +flitBuffer::flitBuffer() +{ + max_size = INFINITE_; +} + +flitBuffer::flitBuffer(int maximum_size) +{ + max_size = maximum_size; +} + +bool +flitBuffer::isEmpty() +{ + return (m_buffer.size() == 0); +} + +bool +flitBuffer::isReady(Cycles curTime) +{ + if (m_buffer.size() != 0 ) { + flit *t_flit = peekTopFlit(); + if (t_flit->get_time() <= curTime) + return true; + } + return false; +} + +void +flitBuffer::print(std::ostream& out) const +{ + out << "[flitBuffer: " << m_buffer.size() << "] " << std::endl; +} + +bool +flitBuffer::isFull() +{ + return (m_buffer.size() >= max_size); +} + +void +flitBuffer::setMaxSize(int maximum) +{ + max_size = maximum; +} + +uint32_t +flitBuffer::functionalWrite(Packet *pkt) +{ + uint32_t num_functional_writes = 0; + + for (unsigned int i = 0; i < m_buffer.size(); ++i) { + if (m_buffer[i]->functionalWrite(pkt)) { + num_functional_writes++; + } + } + + return num_functional_writes; +} diff --git a/src/mem/ruby/network/garnet2.0/flitBuffer.hh b/src/mem/ruby/network/garnet2.0/flitBuffer.hh new file mode 100644 index 000000000..eb6ad6167 --- /dev/null +++ b/src/mem/ruby/network/garnet2.0/flitBuffer.hh @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2008 Princeton University + * Copyright (c) 2016 Georgia Institute of Technology + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Niket Agarwal + * Tushar Krishna + */ + + +#ifndef __MEM_RUBY_NETWORK_GARNET_FLIT_BUFFER_HH__ +#define __MEM_RUBY_NETWORK_GARNET_FLIT_BUFFER_HH__ + +#include <algorithm> +#include <iostream> +#include <vector> + +#include "mem/ruby/network/garnet2.0/CommonTypes.hh" +#include "mem/ruby/network/garnet2.0/flit.hh" + +class flitBuffer +{ + public: + flitBuffer(); + flitBuffer(int maximum_size); + + bool isReady(Cycles curTime); + bool isEmpty(); + void print(std::ostream& out) const; + bool isFull(); + void setMaxSize(int maximum); + + flit * + getTopFlit() + { + flit *f = m_buffer.front(); + std::pop_heap(m_buffer.begin(), m_buffer.end(), flit::greater); + m_buffer.pop_back(); + return f; + } + + flit * + peekTopFlit() + { + return m_buffer.front(); + } + + void + insert(flit *flt) + { + m_buffer.push_back(flt); + std::push_heap(m_buffer.begin(), m_buffer.end(), flit::greater); + } + + uint32_t functionalWrite(Packet *pkt); + + private: + std::vector<flit *> m_buffer; + int max_size; +}; + +inline std::ostream& +operator<<(std::ostream& out, const flitBuffer& obj) +{ + obj.print(out); + out << std::flush; + return out; +} + +#endif // __MEM_RUBY_NETWORK_GARNET_FLIT_BUFFER_HH__ |