dist_etherlink.hh revision 11290:1640dd68b0a4 
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 "params/DistEtherLink.hh"
57
58class DistIface;
59class EthPacketData;
60
61/**
62 * Model for a fixed bandwidth full duplex ethernet link.
63 */
64class DistEtherLink : public EtherObject
65{
66  protected:
67    class LocalIface;
68
69    /**
70     * Model base class for a single uni-directional link.
71     *
72     * The link will encapsulate and transfer Ethernet packets to/from
73     * the message server.
74     */
75    class Link : public Serializable
76    {
77      protected:
78        std::string objName;
79        DistEtherLink *parent;
80        LocalIface *localIface;
81        EtherDump *dump;
82        DistIface *distIface;
83        Event *event;
84        EthPacketPtr packet;
85
86      public:
87        Link(const std::string &name, DistEtherLink *p,
88             EtherDump *d, Event *e) :
89            objName(name), parent(p), localIface(nullptr), dump(d),
90            distIface(nullptr), event(e) {}
91
92        ~Link() {}
93
94        const std::string name() const { return objName; }
95        bool busy() const { return (bool)packet; }
96        void setLocalInt(LocalIface *i) { assert(!localIface); localIface=i; }
97
98        void serialize(CheckpointOut &cp) const override;
99        void unserialize(CheckpointIn &cp) override;
100    };
101
102    /**
103     * Model for a send link.
104     */
105    class TxLink : public Link
106    {
107      protected:
108        /**
109         * Per byte send delay
110         */
111        double ticksPerByte;
112        /**
113         * Random component of the send delay
114         */
115        Tick delayVar;
116
117        /**
118         * Send done callback. Called from doneEvent.
119         */
120        void txDone();
121        typedef EventWrapper<TxLink, &TxLink::txDone> DoneEvent;
122        friend void DoneEvent::process();
123        DoneEvent doneEvent;
124
125      public:
126        TxLink(const std::string &name, DistEtherLink *p,
127               double invBW, Tick delay_var, EtherDump *d) :
128            Link(name, p, d, &doneEvent), ticksPerByte(invBW),
129            delayVar(delay_var), doneEvent(this) {}
130        ~TxLink() {}
131
132        /**
133         * Register the dist interface to be used to talk to the
134         * peer gem5 processes.
135         */
136        void setDistInt(DistIface *m) { assert(!distIface); distIface=m; }
137
138        /**
139         * Initiate sending of a packet via this link.
140         *
141         * @param packet Ethernet packet to send
142         */
143        bool transmit(EthPacketPtr packet);
144    };
145
146    /**
147     * Model for a receive link.
148     */
149    class RxLink : public Link
150    {
151      protected:
152
153        /**
154         * Transmission delay for the simulated Ethernet link.
155         */
156        Tick linkDelay;
157
158        /**
159         * Receive done callback method. Called from doneEvent.
160         */
161        void rxDone();
162        typedef EventWrapper<RxLink, &RxLink::rxDone> DoneEvent;
163        friend void DoneEvent::process();
164        DoneEvent _doneEvent;
165
166      public:
167
168        RxLink(const std::string &name, DistEtherLink *p,
169               Tick delay, EtherDump *d) :
170            Link(name, p, d, &_doneEvent),
171            linkDelay(delay), _doneEvent(this) {}
172        ~RxLink() {}
173
174        /**
175         * Register our dist interface to talk to the peer gem5 processes.
176         */
177        void setDistInt(DistIface *m);
178        /**
179         * Done events will be scheduled by DistIface (so we need the accessor)
180         */
181        const DoneEvent *doneEvent() const { return &_doneEvent; }
182    };
183
184    /**
185     * Interface to the local simulated system
186     */
187    class LocalIface : public EtherInt
188    {
189      private:
190        TxLink *txLink;
191
192      public:
193        LocalIface(const std::string &name, TxLink *tx, RxLink *rx,
194                   DistIface *m);
195
196        bool recvPacket(EthPacketPtr pkt) { return txLink->transmit(pkt); }
197        void sendDone() { peer->sendDone(); }
198        bool isBusy() { return txLink->busy(); }
199    };
200
201
202  protected:
203    /**
204     * Interface to talk to the peer gem5 processes.
205     */
206    DistIface *distIface;
207    /**
208     * Send link
209     */
210    TxLink *txLink;
211    /**
212     * Receive link
213     */
214    RxLink *rxLink;
215    LocalIface *localIface;
216
217    Tick linkDelay;
218
219  public:
220    typedef DistEtherLinkParams Params;
221    DistEtherLink(const Params *p);
222    ~DistEtherLink();
223
224    const Params *
225    params() const
226    {
227        return dynamic_cast<const Params *>(_params);
228    }
229
230    virtual EtherInt *getEthPort(const std::string &if_name,
231                                 int idx) override;
232
233    virtual void init() override;
234    virtual void startup() override;
235
236    void serialize(CheckpointOut &cp) const override;
237    void unserialize(CheckpointIn &cp) override;
238};
239
240#endif // __DEV_DIST_ETHERLINK_HH__
241