coherent_xbar.cc revision 3662
1/*
2 * Copyright (c) 2006 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Ali Saidi
29 */
30
31/**
32 * @file
33 * Definition of a bus object.
34 */
35
36
37#include "base/misc.hh"
38#include "base/trace.hh"
39#include "mem/bus.hh"
40#include "sim/builder.hh"
41
42Port *
43Bus::getPort(const std::string &if_name, int idx)
44{
45    if (if_name == "default") {
46        if (defaultPort == NULL) {
47            defaultPort = new BusPort(csprintf("%s-default",name()), this,
48                                      defaultId);
49            return defaultPort;
50        } else
51            fatal("Default port already set\n");
52    }
53
54    // if_name ignored?  forced to be empty?
55    int id = interfaces.size();
56    BusPort *bp = new BusPort(csprintf("%s-p%d", name(), id), this, id);
57    interfaces.push_back(bp);
58    return bp;
59}
60
61/** Get the ranges of anyone other buses that we are connected to. */
62void
63Bus::init()
64{
65    std::vector<BusPort*>::iterator intIter;
66
67    for (intIter = interfaces.begin(); intIter != interfaces.end(); intIter++)
68        (*intIter)->sendStatusChange(Port::RangeChange);
69}
70
71Bus::BusFreeEvent::BusFreeEvent(Bus *_bus) : Event(&mainEventQueue), bus(_bus)
72{}
73
74void Bus::BusFreeEvent::process()
75{
76    bus->recvRetry(-1);
77}
78
79const char * Bus::BusFreeEvent::description()
80{
81    return "bus became available";
82}
83
84void Bus::occupyBus(PacketPtr pkt)
85{
86    //Bring tickNextIdle up to the present tick
87    //There is some potential ambiguity where a cycle starts, which might make
88    //a difference when devices are acting right around a cycle boundary. Using
89    //a < allows things which happen exactly on a cycle boundary to take up only
90    //the following cycle. Anthing that happens later will have to "wait" for
91    //the end of that cycle, and then start using the bus after that.
92    while (tickNextIdle < curTick)
93        tickNextIdle += clock;
94
95    // The packet will be sent. Figure out how long it occupies the bus, and
96    // how much of that time is for the first "word", aka bus width.
97    int numCycles = 0;
98    // Requests need one cycle to send an address
99    if (pkt->isRequest())
100        numCycles++;
101    else if (pkt->isResponse() || pkt->hasData()) {
102        // If a packet has data, it needs ceil(size/width) cycles to send it
103        // We're using the "adding instead of dividing" trick again here
104        if (pkt->hasData()) {
105            int dataSize = pkt->getSize();
106            for (int transmitted = 0; transmitted < dataSize;
107                    transmitted += width) {
108                numCycles++;
109            }
110        } else {
111            // If the packet didn't have data, it must have been a response.
112            // Those use the bus for one cycle to send their data.
113            numCycles++;
114        }
115    }
116
117    // The first word will be delivered after the current tick, the delivery
118    // of the address if any, and one bus cycle to deliver the data
119    pkt->firstWordTime =
120        tickNextIdle +
121        pkt->isRequest() ? clock : 0 +
122        clock;
123
124    //Advance it numCycles bus cycles.
125    //XXX Should this use the repeated addition trick as well?
126    tickNextIdle += (numCycles * clock);
127    if (!busIdle.scheduled()) {
128        busIdle.schedule(tickNextIdle);
129    } else {
130        busIdle.reschedule(tickNextIdle);
131    }
132    DPRINTF(Bus, "The bus is now occupied from tick %d to %d\n",
133            curTick, tickNextIdle);
134
135    // The bus will become idle once the current packet is delivered.
136    pkt->finishTime = tickNextIdle;
137}
138
139/** Function called by the port when the bus is receiving a Timing
140 * transaction.*/
141bool
142Bus::recvTiming(PacketPtr pkt)
143{
144    Port *port;
145    DPRINTF(Bus, "recvTiming: packet src %d dest %d addr 0x%x cmd %s\n",
146            pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
147
148    BusPort *pktPort;
149    if (pkt->getSrc() == defaultId)
150        pktPort = defaultPort;
151    else pktPort = interfaces[pkt->getSrc()];
152
153    // If the bus is busy, or other devices are in line ahead of the current
154    // one, put this device on the retry list.
155    if (tickNextIdle > curTick ||
156            (retryList.size() && (!inRetry || pktPort != retryList.front()))) {
157        addToRetryList(pktPort);
158        return false;
159    }
160
161    short dest = pkt->getDest();
162    if (dest == Packet::Broadcast) {
163        port = findPort(pkt->getAddr(), pkt->getSrc());
164        if (timingSnoop(pkt, port)) {
165            bool success;
166
167            pkt->flags |= SNOOP_COMMIT;
168            success = timingSnoop(pkt, port);
169            assert(success);
170
171            if (pkt->flags & SATISFIED) {
172                //Cache-Cache transfer occuring
173                if (inRetry) {
174                    retryList.front()->onRetryList(false);
175                    retryList.pop_front();
176                    inRetry = false;
177                }
178                occupyBus(pkt);
179                return true;
180            }
181        } else {
182            //Snoop didn't succeed
183            DPRINTF(Bus, "Adding a retry to RETRY list %i\n", pktPort);
184            addToRetryList(pktPort);
185            return false;
186        }
187    } else {
188        assert(dest >= 0 && dest < interfaces.size());
189        assert(dest != pkt->getSrc()); // catch infinite loops
190        port = interfaces[dest];
191    }
192
193    occupyBus(pkt);
194
195    if (port->sendTiming(pkt))  {
196        // Packet was successfully sent. Return true.
197        // Also take care of retries
198        if (inRetry) {
199            DPRINTF(Bus, "Remove retry from list %i\n", retryList.front());
200            retryList.front()->onRetryList(false);
201            retryList.pop_front();
202            inRetry = false;
203        }
204        return true;
205    }
206
207    // Packet not successfully sent. Leave or put it on the retry list.
208    DPRINTF(Bus, "Adding a retry to RETRY list %i\n", pktPort);
209    addToRetryList(pktPort);
210    return false;
211}
212
213void
214Bus::recvRetry(int id)
215{
216    DPRINTF(Bus, "Received a retry\n");
217    // If there's anything waiting, and the bus isn't busy...
218    if (retryList.size() && curTick >= tickNextIdle) {
219        //retryingPort = retryList.front();
220        inRetry = true;
221        DPRINTF(Bus, "Sending a retry\n");
222        retryList.front()->sendRetry();
223        // If inRetry is still true, sendTiming wasn't called
224        if (inRetry)
225        {
226            retryList.front()->onRetryList(false);
227            retryList.pop_front();
228            inRetry = false;
229
230            //Bring tickNextIdle up to the present
231            while (tickNextIdle < curTick)
232                tickNextIdle += clock;
233
234            //Burn a cycle for the missed grant.
235            tickNextIdle += clock;
236
237            if (!busIdle.scheduled()) {
238                busIdle.schedule(tickNextIdle);
239            } else {
240                busIdle.reschedule(tickNextIdle);
241            }
242        }
243    }
244    //If we weren't able to drain before, we might be able to now.
245    if (drainEvent && retryList.size() == 0 && curTick >= tickNextIdle) {
246        drainEvent->process();
247        // Clear the drain event once we're done with it.
248        drainEvent = NULL;
249    }
250}
251
252Port *
253Bus::findPort(Addr addr, int id)
254{
255    /* An interval tree would be a better way to do this. --ali. */
256    int dest_id = -1;
257    int i = 0;
258    bool found = false;
259    AddrRangeIter iter;
260
261    while (i < portList.size() && !found)
262    {
263        if (portList[i].range == addr) {
264            dest_id = portList[i].portId;
265            found = true;
266            DPRINTF(Bus, "  found addr %#llx on device %d\n", addr, dest_id);
267        }
268        i++;
269    }
270
271    // Check if this matches the default range
272    if (dest_id == -1) {
273        for (iter = defaultRange.begin(); iter != defaultRange.end(); iter++) {
274            if (*iter == addr) {
275                DPRINTF(Bus, "  found addr %#llx on default\n", addr);
276                return defaultPort;
277            }
278        }
279
280        if (responderSet) {
281            panic("Unable to find destination for addr (user set default "
282                  "responder): %#llx", addr);
283        } else {
284            DPRINTF(Bus, "Unable to find destination for addr: %#llx, will use "
285                    "default port", addr);
286
287            return defaultPort;
288        }
289    }
290
291
292    // we shouldn't be sending this back to where it came from
293    // only on a functional access and then we should terminate
294    // the cyclical call.
295    if (dest_id == id)
296        return 0;
297
298    return interfaces[dest_id];
299}
300
301std::vector<int>
302Bus::findSnoopPorts(Addr addr, int id)
303{
304    int i = 0;
305    AddrRangeIter iter;
306    std::vector<int> ports;
307
308    while (i < portSnoopList.size())
309    {
310        if (portSnoopList[i].range == addr && portSnoopList[i].portId != id) {
311            //Careful  to not overlap ranges
312            //or snoop will be called more than once on the port
313
314            //@todo Fix this hack because ranges are overlapping
315            //need to make sure we dont't create overlapping ranges
316            bool hack_overlap = false;
317            int size = ports.size();
318            for (int j=0; j < size; j++) {
319                if (ports[j] == portSnoopList[i].portId)
320                    hack_overlap = true;
321            }
322
323            if (!hack_overlap)
324                ports.push_back(portSnoopList[i].portId);
325//            DPRINTF(Bus, "  found snoop addr %#llx on device%d\n", addr,
326//                    portSnoopList[i].portId);
327        }
328        i++;
329    }
330    return ports;
331}
332
333Tick
334Bus::atomicSnoop(PacketPtr pkt)
335{
336    std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
337    Tick response_time = 0;
338
339    while (!ports.empty())
340    {
341        Tick response = interfaces[ports.back()]->sendAtomic(pkt);
342        if (response) {
343            assert(!response_time);  //Multiple responders
344            response_time = response;
345        }
346        ports.pop_back();
347    }
348    return response_time;
349}
350
351void
352Bus::functionalSnoop(PacketPtr pkt)
353{
354    std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
355
356    //The packet may be changed by another bus on snoops, restore the id after each
357    int id = pkt->getSrc();
358    while (!ports.empty() && pkt->result != Packet::Success)
359    {
360        interfaces[ports.back()]->sendFunctional(pkt);
361        ports.pop_back();
362        pkt->setSrc(id);
363    }
364}
365
366bool
367Bus::timingSnoop(PacketPtr pkt, Port* responder)
368{
369    std::vector<int> ports = findSnoopPorts(pkt->getAddr(), pkt->getSrc());
370    bool success = true;
371
372    while (!ports.empty() && success)
373    {
374        if (interfaces[ports.back()] != responder) //Don't call if responder also, once will do
375            success = interfaces[ports.back()]->sendTiming(pkt);
376        ports.pop_back();
377    }
378
379    return success;
380}
381
382
383/** Function called by the port when the bus is receiving a Atomic
384 * transaction.*/
385Tick
386Bus::recvAtomic(PacketPtr pkt)
387{
388    DPRINTF(Bus, "recvAtomic: packet src %d dest %d addr 0x%x cmd %s\n",
389            pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
390    assert(pkt->getDest() == Packet::Broadcast);
391    pkt->flags |= SNOOP_COMMIT;
392
393    // Assume one bus cycle in order to get through.  This may have
394    // some clock skew issues yet again...
395    pkt->finishTime = curTick + clock;
396
397    Tick snoopTime = atomicSnoop(pkt);
398
399    if (snoopTime)
400        return snoopTime;  //Snoop satisfies it
401    else
402        return findPort(pkt->getAddr(), pkt->getSrc())->sendAtomic(pkt);
403}
404
405/** Function called by the port when the bus is receiving a Functional
406 * transaction.*/
407void
408Bus::recvFunctional(PacketPtr pkt)
409{
410    DPRINTF(Bus, "recvFunctional: packet src %d dest %d addr 0x%x cmd %s\n",
411            pkt->getSrc(), pkt->getDest(), pkt->getAddr(), pkt->cmdString());
412    assert(pkt->getDest() == Packet::Broadcast);
413    pkt->flags |= SNOOP_COMMIT;
414
415    functionalSnoop(pkt);
416
417    // If the snooping found what we were looking for, we're done.
418    if (pkt->result != Packet::Success) {
419        Port* port = findPort(pkt->getAddr(), pkt->getSrc());
420        if (port)
421            port->sendFunctional(pkt);
422    }
423}
424
425/** Function called by the port when the bus is receiving a status change.*/
426void
427Bus::recvStatusChange(Port::Status status, int id)
428{
429    AddrRangeList ranges;
430    AddrRangeList snoops;
431    int x;
432    AddrRangeIter iter;
433
434    assert(status == Port::RangeChange &&
435           "The other statuses need to be implemented.");
436
437    DPRINTF(BusAddrRanges, "received RangeChange from device id %d\n", id);
438
439    if (id == defaultId) {
440        defaultRange.clear();
441        // Only try to update these ranges if the user set a default responder.
442        if (responderSet) {
443            defaultPort->getPeerAddressRanges(ranges, snoops);
444            assert(snoops.size() == 0);
445            for(iter = ranges.begin(); iter != ranges.end(); iter++) {
446                defaultRange.push_back(*iter);
447                DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for default range\n",
448                        iter->start, iter->end);
449            }
450        }
451    } else {
452
453        assert((id < interfaces.size() && id >= 0) || id == defaultId);
454        Port *port = interfaces[id];
455        std::vector<DevMap>::iterator portIter;
456        std::vector<DevMap>::iterator snoopIter;
457
458        // Clean out any previously existent ids
459        for (portIter = portList.begin(); portIter != portList.end(); ) {
460            if (portIter->portId == id)
461                portIter = portList.erase(portIter);
462            else
463                portIter++;
464        }
465
466        for (snoopIter = portSnoopList.begin(); snoopIter != portSnoopList.end(); ) {
467            if (snoopIter->portId == id)
468                snoopIter = portSnoopList.erase(snoopIter);
469            else
470                snoopIter++;
471        }
472
473        port->getPeerAddressRanges(ranges, snoops);
474
475        for(iter = snoops.begin(); iter != snoops.end(); iter++) {
476            DevMap dm;
477            dm.portId = id;
478            dm.range = *iter;
479
480            //@todo, make sure we don't overlap ranges
481            DPRINTF(BusAddrRanges, "Adding snoop range %#llx - %#llx for id %d\n",
482                    dm.range.start, dm.range.end, id);
483            portSnoopList.push_back(dm);
484        }
485
486        for(iter = ranges.begin(); iter != ranges.end(); iter++) {
487            DevMap dm;
488            dm.portId = id;
489            dm.range = *iter;
490
491            DPRINTF(BusAddrRanges, "Adding range %#llx - %#llx for id %d\n",
492                    dm.range.start, dm.range.end, id);
493            portList.push_back(dm);
494        }
495    }
496    DPRINTF(MMU, "port list has %d entries\n", portList.size());
497
498    // tell all our peers that our address range has changed.
499    // Don't tell the device that caused this change, it already knows
500    for (x = 0; x < interfaces.size(); x++)
501        if (x != id)
502            interfaces[x]->sendStatusChange(Port::RangeChange);
503
504    if (id != defaultId && defaultPort)
505        defaultPort->sendStatusChange(Port::RangeChange);
506}
507
508void
509Bus::addressRanges(AddrRangeList &resp, AddrRangeList &snoop, int id)
510{
511    std::vector<DevMap>::iterator portIter;
512    AddrRangeIter dflt_iter;
513    bool subset;
514
515    resp.clear();
516    snoop.clear();
517
518    DPRINTF(BusAddrRanges, "received address range request, returning:\n");
519
520    for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end();
521            dflt_iter++) {
522        resp.push_back(*dflt_iter);
523        DPRINTF(BusAddrRanges, "  -- Dflt: %#llx : %#llx\n",dflt_iter->start,
524                dflt_iter->end);
525    }
526    for (portIter = portList.begin(); portIter != portList.end(); portIter++) {
527        subset = false;
528        for (dflt_iter = defaultRange.begin(); dflt_iter != defaultRange.end();
529                dflt_iter++) {
530            if ((portIter->range.start < dflt_iter->start &&
531                portIter->range.end >= dflt_iter->start) ||
532               (portIter->range.start < dflt_iter->end &&
533                portIter->range.end >= dflt_iter->end))
534                fatal("Devices can not set ranges that itersect the default set\
535                        but are not a subset of the default set.\n");
536            if (portIter->range.start >= dflt_iter->start &&
537                portIter->range.end <= dflt_iter->end) {
538                subset = true;
539                DPRINTF(BusAddrRanges, "  -- %#llx : %#llx is a SUBSET\n",
540                    portIter->range.start, portIter->range.end);
541            }
542        }
543        if (portIter->portId != id && !subset) {
544            resp.push_back(portIter->range);
545            DPRINTF(BusAddrRanges, "  -- %#llx : %#llx\n",
546                    portIter->range.start, portIter->range.end);
547        }
548    }
549
550    for (portIter = portSnoopList.begin();
551         portIter != portSnoopList.end(); portIter++)
552    {
553        if (portIter->portId != id) {
554            snoop.push_back(portIter->range);
555            DPRINTF(BusAddrRanges, "  -- Snoop: %#llx : %#llx\n",
556                    portIter->range.start, portIter->range.end);
557            //@todo We need to properly insert snoop ranges
558            //not overlapping the ranges (multiple)
559        }
560    }
561}
562
563unsigned int
564Bus::drain(Event * de)
565{
566    //We should check that we're not "doing" anything, and that noone is
567    //waiting. We might be idle but have someone waiting if the device we
568    //contacted for a retry didn't actually retry.
569    if (curTick >= tickNextIdle && retryList.size() == 0) {
570        return 0;
571    } else {
572        drainEvent = de;
573        return 1;
574    }
575}
576
577BEGIN_DECLARE_SIM_OBJECT_PARAMS(Bus)
578
579    Param<int> bus_id;
580    Param<int> clock;
581    Param<int> width;
582    Param<bool> responder_set;
583
584END_DECLARE_SIM_OBJECT_PARAMS(Bus)
585
586BEGIN_INIT_SIM_OBJECT_PARAMS(Bus)
587    INIT_PARAM(bus_id, "a globally unique bus id"),
588    INIT_PARAM(clock, "bus clock speed"),
589    INIT_PARAM(width, "width of the bus (bits)"),
590    INIT_PARAM(responder_set, "Is a default responder set by the user")
591END_INIT_SIM_OBJECT_PARAMS(Bus)
592
593CREATE_SIM_OBJECT(Bus)
594{
595    return new Bus(getInstanceName(), bus_id, clock, width, responder_set);
596}
597
598REGISTER_SIM_OBJECT("Bus", Bus)
599