dist_etherlink.hh revision 13766:4ecebdee8da4 
1/*
2 * Copyright (c) 2015 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder.  You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions are
16 * met: redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer;
18 * redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution;
21 * neither the name of the copyright holders nor the names of its
22 * contributors may be used to endorse or promote products derived from
23 * this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 *
37 * Authors: Gabor Dozsa
38 */
39
40/* @file
41 * Device module for a full duplex ethernet link for dist gem5 simulations.
42 *
43 * See comments in dev/net/dist_iface.hh for a generic description of dist
44 * gem5 simulations.
45 *
46 * This class is meant to be a drop in replacement for the EtherLink class for
47 * dist gem5 runs.
48 *
49 */
50#ifndef __DEV_DIST_ETHERLINK_HH__
51#define __DEV_DIST_ETHERLINK_HH__
52
53#include <iostream>
54
55#include "dev/net/etherlink.hh"
56#include "dev/net/etherobject.hh"
57#include "params/DistEtherLink.hh"
58
59class DistIface;
60class EthPacketData;
61
62/**
63 * Model for a fixed bandwidth full duplex ethernet link.
64 */
65class DistEtherLink : public SimObject, public EtherObject
66{
67  protected:
68    class LocalIface;
69
70    /**
71     * Model base class for a single uni-directional link.
72     *
73     * The link will encapsulate and transfer Ethernet packets to/from
74     * the message server.
75     */
76    class Link : public Serializable
77    {
78      protected:
79        std::string objName;
80        DistEtherLink *parent;
81        LocalIface *localIface;
82        EtherDump *dump;
83        DistIface *distIface;
84        Event *event;
85        EthPacketPtr packet;
86
87      public:
88        Link(const std::string &name, DistEtherLink *p,
89             EtherDump *d, Event *e) :
90            objName(name), parent(p), localIface(nullptr), dump(d),
91            distIface(nullptr), event(e) {}
92
93        ~Link() {}
94
95        const std::string name() const { return objName; }
96        bool busy() const { return (bool)packet; }
97        void setLocalInt(LocalIface *i) { assert(!localIface); localIface=i; }
98
99        void serialize(CheckpointOut &cp) const override;
100        void unserialize(CheckpointIn &cp) override;
101    };
102
103    /**
104     * Model for a send link.
105     */
106    class TxLink : public Link
107    {
108      protected:
109        /**
110         * Per byte send delay
111         */
112        double ticksPerByte;
113        /**
114         * Random component of the send delay
115         */
116        Tick delayVar;
117
118        /**
119         * Send done callback. Called from doneEvent.
120         */
121        void txDone();
122        EventFunctionWrapper doneEvent;
123
124      public:
125        TxLink(const std::string &name, DistEtherLink *p,
126               double invBW, Tick delay_var, EtherDump *d) :
127            Link(name, p, d, &doneEvent), ticksPerByte(invBW),
128            delayVar(delay_var), doneEvent([this]{ txDone(); }, name) {}
129        ~TxLink() {}
130
131        /**
132         * Register the dist interface to be used to talk to the
133         * peer gem5 processes.
134         */
135        void setDistInt(DistIface *m) { assert(!distIface); distIface=m; }
136
137        /**
138         * Initiate sending of a packet via this link.
139         *
140         * @param packet Ethernet packet to send
141         */
142        bool transmit(EthPacketPtr packet);
143    };
144
145    /**
146     * Model for a receive link.
147     */
148    class RxLink : public Link
149    {
150      protected:
151
152        /**
153         * Transmission delay for the simulated Ethernet link.
154         */
155        Tick linkDelay;
156
157        /**
158         * Receive done callback method. Called from doneEvent.
159         */
160        void rxDone();
161        EventFunctionWrapper _doneEvent;
162
163      public:
164
165        RxLink(const std::string &name, DistEtherLink *p,
166               Tick delay, EtherDump *d) :
167            Link(name, p, d, &_doneEvent), linkDelay(delay),
168            _doneEvent([this]{ rxDone(); }, name) {}
169        ~RxLink() {}
170
171        /**
172         * Register our dist interface to talk to the peer gem5 processes.
173         */
174        void setDistInt(DistIface *m);
175        /**
176         * Done events will be scheduled by DistIface (so we need the accessor)
177         */
178        const EventFunctionWrapper *doneEvent() const { return &_doneEvent; }
179    };
180
181    /**
182     * Interface to the local simulated system
183     */
184    class LocalIface : public EtherInt
185    {
186      private:
187        TxLink *txLink;
188
189      public:
190        LocalIface(const std::string &name, TxLink *tx, RxLink *rx,
191                   DistIface *m);
192
193        bool recvPacket(EthPacketPtr pkt) { return txLink->transmit(pkt); }
194        void sendDone() { peer->sendDone(); }
195        bool isBusy() { return txLink->busy(); }
196    };
197
198
199  protected:
200    /**
201     * Interface to talk to the peer gem5 processes.
202     */
203    DistIface *distIface;
204    /**
205     * Send link
206     */
207    TxLink *txLink;
208    /**
209     * Receive link
210     */
211    RxLink *rxLink;
212    LocalIface *localIface;
213
214    Tick linkDelay;
215
216  public:
217    typedef DistEtherLinkParams Params;
218    DistEtherLink(const Params *p);
219    ~DistEtherLink();
220
221    const Params *
222    params() const
223    {
224        return dynamic_cast<const Params *>(_params);
225    }
226
227    EtherInt *getEthPort(const std::string &if_name, int idx) override;
228
229    virtual void init() override;
230    virtual void startup() override;
231
232    void serialize(CheckpointOut &cp) const override;
233    void unserialize(CheckpointIn &cp) override;
234};
235
236#endif // __DEV_DIST_ETHERLINK_HH__
237