X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=dev%2Fetherlink.cc;h=0acc50b0b32b2298fe1399af86c85e632daf502d;hb=91601f44948060939527bad44e82b1379168fc6c;hp=6fb7187d21a761969332bb6e244d0a664a7fc750;hpb=166def1f5663bda1766b003fab4c46bc905fdb8d;p=gem5.git diff --git a/dev/etherlink.cc b/dev/etherlink.cc index 6fb7187d2..0acc50b0b 100644 --- a/dev/etherlink.cc +++ b/dev/etherlink.cc @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003 The Regents of The University of Michigan + * Copyright (c) 2002-2004 The Regents of The University of Michigan * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -41,18 +41,21 @@ #include "dev/etherlink.hh" #include "dev/etherpkt.hh" #include "sim/builder.hh" +#include "sim/serialize.hh" +#include "sim/system.hh" #include "sim/universe.hh" using namespace std; -EtherLink::EtherLink(const std::string &name, EtherInt *i1, EtherInt *i2, - Tick speed, EtherDump *dump) +EtherLink::EtherLink(const string &name, EtherInt *i1, EtherInt *i2, + Tick speed, Tick dly, EtherDump *dump) : SimObject(name) { double rate = ((double)ticksPerSecond * 8.0) / (double)speed; + Tick delay = US2Ticks(dly); - link1 = new Link(name + ".link1", rate, dump); - link2 = new Link(name + ".link2", rate, dump); + link1 = new Link(name + ".link1", rate, delay, dump); + link2 = new Link(name + ".link2", rate, delay, dump); int1 = new Interface(name + ".int1", link1, link2); int2 = new Interface(name + ".int2", link2, link1); @@ -72,28 +75,76 @@ EtherLink::~EtherLink() delete int2; } -EtherLink::Interface::Interface(const std::string &name, Link *tx, Link *rx) +EtherLink::Interface::Interface(const string &name, Link *tx, Link *rx) : EtherInt(name), txlink(tx) { tx->setTxInt(this); rx->setRxInt(this); } -EtherLink::Link::Link(const std::string &name, double rate, EtherDump *d) - : objName(name), txint(NULL), rxint(NULL), ticks_per_byte(rate), - dump(d), event(&mainEventQueue, this) +EtherLink::Link::Link(const string &name, double rate, Tick delay, + EtherDump *d) + : objName(name), txint(NULL), rxint(NULL), ticksPerByte(rate), + linkDelay(delay), dump(d), doneEvent(this) {} +void +EtherLink::serialize(ostream &os) +{ + nameOut(os, name() + ".link1"); + link1->serialize(os); + nameOut(os, name() + ".link2"); + link2->serialize(os); +} + +void +EtherLink::unserialize(Checkpoint *cp, const string §ion) +{ + link1->unserialize(cp, section + ".link1"); + link2->unserialize(cp, section + ".link2"); +} + +void +EtherLink::Link::txComplete(PacketPtr packet) +{ + DPRINTF(Ethernet, "packet received: len=%d\n", packet->length); + DDUMP(EthernetData, packet->data, packet->length); + rxint->sendPacket(packet); +} + +class LinkDelayEvent : public Event +{ + protected: + EtherLink::Link *link; + PacketPtr packet; + + // non-scheduling version for createForUnserialize() + LinkDelayEvent(EtherLink::Link *link); + + public: + LinkDelayEvent(EtherLink::Link *link, PacketPtr pkt, Tick when); + + void process(); + + virtual void serialize(ostream &os); + virtual void unserialize(Checkpoint *cp, const string §ion); + static Serializable *createForUnserialize(Checkpoint *cp, + const string §ion); +}; + + void EtherLink::Link::txDone() { if (dump) dump->dump(packet); - DPRINTF(Ethernet, "EtherLink packet received: len=%d\n", packet->length); - DDUMP(EthernetData, packet->data, packet->length); - - rxint->sendPacket(packet); + if (linkDelay > 0) { + DPRINTF(Ethernet, "packet delayed: delay=%d\n", linkDelay); + new LinkDelayEvent(this, packet, curTick + linkDelay); + } else { + txComplete(packet); + } packet = 0; assert(!busy()); @@ -105,44 +156,132 @@ bool EtherLink::Link::transmit(PacketPtr pkt) { if (busy()) { - DPRINTF(Ethernet, "EtherLink packet not sent, link busy\n"); + DPRINTF(Ethernet, "packet not sent, link busy\n"); return false; } - DPRINTF(Ethernet, "EtherLink packet sent: len=%d\n", pkt->length); + DPRINTF(Ethernet, "packet sent: len=%d\n", pkt->length); DDUMP(EthernetData, pkt->data, pkt->length); packet = pkt; - int delay = (int)ceil(((double)pkt->length * ticks_per_byte) + 1.0); - DPRINTF(Ethernet, "EtherLink scheduling packet: delay=%d, (rate=%f)\n", - delay, ticks_per_byte); - event.schedule(curTick + delay); + Tick delay = (Tick)ceil(((double)pkt->length * ticksPerByte) + 1.0); + DPRINTF(Ethernet, "scheduling packet: delay=%d, (rate=%f)\n", + delay, ticksPerByte); + doneEvent.schedule(curTick + delay); return true; } +void +EtherLink::Link::serialize(ostream &os) +{ + bool packet_exists = packet; + SERIALIZE_SCALAR(packet_exists); + + bool event_scheduled = doneEvent.scheduled(); + SERIALIZE_SCALAR(event_scheduled); + if (event_scheduled) { + Tick event_time = doneEvent.when(); + SERIALIZE_SCALAR(event_time); + } + + if (packet_exists) + packet->serialize("packet", os); +} + +void +EtherLink::Link::unserialize(Checkpoint *cp, const string §ion) +{ + bool packet_exists; + UNSERIALIZE_SCALAR(packet_exists); + if (packet_exists) { + packet = new PacketData(16384); + packet->unserialize("packet", cp, section); + } + + bool event_scheduled; + UNSERIALIZE_SCALAR(event_scheduled); + if (event_scheduled) { + Tick event_time; + UNSERIALIZE_SCALAR(event_time); + doneEvent.schedule(event_time); + } +} + +LinkDelayEvent::LinkDelayEvent(EtherLink::Link *l) + : Event(&mainEventQueue), link(l) +{ + setFlags(AutoSerialize); + setFlags(AutoDelete); +} + +LinkDelayEvent::LinkDelayEvent(EtherLink::Link *l, PacketPtr p, Tick when) + : Event(&mainEventQueue), link(l), packet(p) +{ + setFlags(AutoSerialize); + setFlags(AutoDelete); + schedule(when); +} + +void +LinkDelayEvent::process() +{ + link->txComplete(packet); +} + +void +LinkDelayEvent::serialize(ostream &os) +{ + paramOut(os, "type", string("LinkDelayEvent")); + Event::serialize(os); + SERIALIZE_OBJPTR(link); + + packet->serialize("packet", os); +} + + +void +LinkDelayEvent::unserialize(Checkpoint *cp, const string §ion) +{ + Event::unserialize(cp, section); + packet = new PacketData(16384); + packet->unserialize("packet", cp, section); +} + + +Serializable * +LinkDelayEvent::createForUnserialize(Checkpoint *cp, const string §ion) +{ + EtherLink::Link *link; + UNSERIALIZE_OBJPTR(link); + return new LinkDelayEvent(link); +} + +REGISTER_SERIALIZEABLE("LinkDelayEvent", LinkDelayEvent) + BEGIN_DECLARE_SIM_OBJECT_PARAMS(EtherLink) - SimObjectParam interface1; - SimObjectParam interface2; - Param link_speed; - SimObjectParam packet_dump; + SimObjectParam int1; + SimObjectParam int2; + Param speed; + Param delay; + SimObjectParam dump; END_DECLARE_SIM_OBJECT_PARAMS(EtherLink) BEGIN_INIT_SIM_OBJECT_PARAMS(EtherLink) - INIT_PARAM(interface1, "interface 1"), - INIT_PARAM(interface2, "interface 2"), - INIT_PARAM_DFLT(link_speed, "link speed in bits per second", 100000000), - INIT_PARAM_DFLT(packet_dump, "object to dump network packets to", NULL) + INIT_PARAM(int1, "interface 1"), + INIT_PARAM(int2, "interface 2"), + INIT_PARAM_DFLT(speed, "link speed in bits per second", 100000000), + INIT_PARAM_DFLT(delay, "transmit delay of packets in us", 0), + INIT_PARAM_DFLT(dump, "object to dump network packets to", NULL) END_INIT_SIM_OBJECT_PARAMS(EtherLink) CREATE_SIM_OBJECT(EtherLink) { - return new EtherLink(getInstanceName(), interface1, interface2, link_speed, - packet_dump); + return new EtherLink(getInstanceName(), int1, int2, speed, delay, dump); } REGISTER_SIM_OBJECT("EtherLink", EtherLink)