ParsedElement
Animxmlparser::parseAnim ()
{
ParsedElement parsedElement;
parsedElement.type = XML_ANIM;
parsedElement.version = m_version;
QString v = m_reader->attributes ().value ("ver").toString ();
if (!v.contains ("netanim-"))
return parsedElement;
v = v.replace ("netanim-","");
m_version = v.toDouble ();
if (m_version < ANIM_MIN_VERSION)
{
AnimatorMode::getInstance ()->showPopup ("This XML format is not supported. Minimum Version:" + QString::number (ANIM_MIN_VERSION));
NS_FATAL_ERROR ("This XML format is not supported. Minimum Version:" << ANIM_MIN_VERSION);
}
parsedElement.version = m_version;
//qDebug (QString::number (m_version));
QString fileType = m_reader->attributes ().value ("filetype").toString ();
if (fileType != "animation")
{
AnimatorMode::getInstance ()->showPopup ("filetype must be == animation. Invalid animation trace file?");
NS_FATAL_ERROR ("Invalid animation trace file");
}
return parsedElement;
}
uint32_t
PeerLinkFrameStart::Deserialize (Buffer::Iterator start)
{
Buffer::Iterator i = start;
NS_ASSERT (m_subtype < 3);
{
uint8_t id = i.ReadU8 ();
uint8_t length = i.ReadU8 ();
m_protocol.DeserializeInformationField (i, length);
if ((m_protocol.ElementId () != (WifiInformationElementId) id) || (m_protocol.GetInformationFieldSize () != length))
{
NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
}
i.Next (m_protocol.GetInformationFieldSize ());
}
if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
{
m_capability = i.ReadLsbtohU16 ();
}
if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) == m_subtype)
{
m_aid = i.ReadLsbtohU16 ();
}
if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
{
i = m_rates.Deserialize (i);
i = m_rates.extended.DeserializeIfPresent (i);
}
if ((uint8_t)(WifiActionHeader::PEER_LINK_CONFIRM) != m_subtype)
{
uint8_t id = i.ReadU8 ();
uint8_t length = i.ReadU8 ();
m_meshId.DeserializeInformationField (i, length);
if ((m_meshId.ElementId () != (WifiInformationElementId) id) || (m_meshId.GetInformationFieldSize () != length))
{
NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
}
i.Next (m_meshId.GetInformationFieldSize ());
}
if ((uint8_t)(WifiActionHeader::PEER_LINK_CLOSE) != m_subtype)
{
uint8_t id = i.ReadU8 ();
uint8_t length = i.ReadU8 ();
m_config.DeserializeInformationField (i, length);
if ((m_config.ElementId () != (WifiInformationElementId) id) || (m_config.GetInformationFieldSize () != length))
{
NS_FATAL_ERROR ("Broken frame: Element ID does not match IE itself!");
}
i.Next (m_config.GetInformationFieldSize ());
}
else
{
m_reasonCode = i.ReadLsbtohU16 ();
}
return i.GetDistanceFrom (start);
}
bool
BlockAckManager::ExistsAgreementInState (Mac48Address recipient, uint8_t tid,
enum OriginatorBlockAckAgreement::State state) const
{
NS_LOG_FUNCTION (this << recipient << static_cast<uint32_t> (tid) << state);
AgreementsCI it;
it = m_agreements.find (std::make_pair (recipient, tid));
if (it != m_agreements.end ())
{
switch (state)
{
case OriginatorBlockAckAgreement::INACTIVE:
return it->second.first.IsInactive ();
case OriginatorBlockAckAgreement::ESTABLISHED:
return it->second.first.IsEstablished ();
case OriginatorBlockAckAgreement::PENDING:
return it->second.first.IsPending ();
case OriginatorBlockAckAgreement::UNSUCCESSFUL:
return it->second.first.IsUnsuccessful ();
default:
NS_FATAL_ERROR ("Invalid state for block ack agreement");
}
}
return false;
}
void
FibHelper::RemoveRoute(Ptr<Node> node, const Name& prefix, Ptr<Node> otherNode)
{
for (uint32_t deviceId = 0; deviceId < node->GetNDevices(); deviceId++) {
Ptr<PointToPointNetDevice> netDevice =
DynamicCast<PointToPointNetDevice>(node->GetDevice(deviceId));
if (netDevice == 0)
continue;
Ptr<Channel> channel = netDevice->GetChannel();
if (channel == 0)
continue;
if (channel->GetDevice(0)->GetNode() == otherNode
|| channel->GetDevice(1)->GetNode() == otherNode) {
Ptr<L3Protocol> ndn = node->GetObject<L3Protocol>();
NS_ASSERT_MSG(ndn != 0, "Ndn stack should be installed on the node");
shared_ptr<Face> face = ndn->getFaceByNetDevice(netDevice);
NS_ASSERT_MSG(face != 0, "There is no face associated with the p2p link");
RemoveRoute(node, prefix, face);
return;
}
}
NS_FATAL_ERROR("Cannot remove route: Node# " << node->GetId() << " and Node# " << otherNode->GetId()
<< " are not connected");
}
Ptr<FaceContainer>
StackHelper::Install(Ptr<Node> node) const
{
Ptr<FaceContainer> faces = Create<FaceContainer>();
if (node->GetObject<L3Protocol>() != 0) {
NS_FATAL_ERROR("Cannot re-install NDN stack on node "
<< node->GetId());
return 0;
}
Ptr<L3Protocol> ndn = m_ndnFactory.Create<L3Protocol>();
ndn->getConfig().put("tables.cs_max_packets", (m_maxCsSize == 0) ? 1 : m_maxCsSize);
// Create and aggregate content store if NFD's contest store has been disabled
if (m_maxCsSize == 0) {
ndn->AggregateObject(m_contentStoreFactory.Create<ContentStore>());
}
// Aggregate L3Protocol on node (must be after setting ndnSIM CS)
node->AggregateObject(ndn);
for (uint32_t index = 0; index < node->GetNDevices(); index++) {
Ptr<NetDevice> device = node->GetDevice(index);
// This check does not make sense: LoopbackNetDevice is installed only if IP stack is installed,
// Normally, ndnSIM works without IP stack, so no reason to check
// if (DynamicCast<LoopbackNetDevice> (device) != 0)
// continue; // don't create face for a LoopbackNetDevice
faces->Add(this->createAndRegisterFace(node, ndn, device));
}
return faces;
}
const LteAnr::NeighbourRelation_t *
LteAnr::Find (uint16_t cellId) const
{
NeighbourRelationTable_t::const_iterator it = m_neighbourRelationTable.find (cellId);
if (it == m_neighbourRelationTable.end ())
{
NS_FATAL_ERROR ("Cell ID " << cellId << " cannot be found in NRT");
}
return &(it->second);
}
Ptr<Packet>
BlockAckManager::ScheduleBlockAckReqIfNeeded (Mac48Address recipient, uint8_t tid)
{
/* This method checks if a BlockAckRequest frame should be send to the recipient station.
Number of packets under block ack is specified in OriginatorBlockAckAgreement object but sometimes
this number could be incorrect. In fact is possible that a block ack agreement exists for n
packets but some of these packets are dropped due to MSDU lifetime expiration.
*/
NS_LOG_FUNCTION (this << recipient << static_cast<uint32_t> (tid));
AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));
NS_ASSERT (it != m_agreements.end ());
if ((*it).second.first.IsBlockAckRequestNeeded ()
|| (GetNRetryNeededPackets (recipient, tid) == 0
&& m_queue->GetNPacketsByTidAndAddress (tid, WifiMacHeader::ADDR1, recipient) == 0))
{
OriginatorBlockAckAgreement &agreement = (*it).second.first;
agreement.CompleteExchange ();
CtrlBAckRequestHeader reqHdr;
if (m_blockAckType == BASIC_BLOCK_ACK || m_blockAckType == COMPRESSED_BLOCK_ACK)
{
reqHdr.SetType (m_blockAckType);
reqHdr.SetTidInfo (agreement.GetTid ());
reqHdr.SetStartingSequence (agreement.GetStartingSequence ());
}
else if (m_blockAckType == MULTI_TID_BLOCK_ACK)
{
NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
}
else
{
NS_FATAL_ERROR ("Invalid block ack type.");
}
Ptr<Packet> bar = Create<Packet> ();
bar->AddHeader (reqHdr);
return bar;
}
return 0;
}
void
LteAnr::RemoveNeighbourRelation (uint16_t cellId)
{
NS_LOG_FUNCTION (this << m_servingCellId << cellId);
NeighbourRelationTable_t::iterator it = m_neighbourRelationTable.find (cellId);
if (it != m_neighbourRelationTable.end ())
{
NS_FATAL_ERROR ("Cell ID " << cellId << " cannot be found in NRT");
}
m_neighbourRelationTable.erase (it);
}
void
LteAnr::AddNeighbourRelation (uint16_t cellId)
{
NS_LOG_FUNCTION (this << m_servingCellId << cellId);
if (cellId == m_servingCellId)
{
NS_FATAL_ERROR ("Serving cell ID " << cellId << " may not be added into NRT");
}
if (m_neighbourRelationTable.find (cellId) != m_neighbourRelationTable.end ())
{
NS_FATAL_ERROR ("There is already an entry in the NRT for cell ID " << cellId);
}
NeighbourRelation_t neighbourRelation;
neighbourRelation.noRemove = true;
neighbourRelation.noHo = true;
neighbourRelation.noX2 = false;
neighbourRelation.detectedAsNeighbour = false;
m_neighbourRelationTable[cellId] = neighbourRelation;
}
void
LinkControlHelper::setErrorRate(Ptr<Node> node1, Ptr<Node> node2, double errorRate)
{
NS_LOG_FUNCTION(node1 << node2 << errorRate);
NS_ASSERT(node1 != nullptr && node2 != nullptr);
NS_ASSERT(errorRate <= 1.0);
Ptr<ndn::L3Protocol> ndn1 = node1->GetObject<ndn::L3Protocol>();
Ptr<ndn::L3Protocol> ndn2 = node2->GetObject<ndn::L3Protocol>();
NS_ASSERT(ndn1 != nullptr && ndn2 != nullptr);
// iterate over all faces to find the right one
for (const auto& face : ndn1->getForwarder()->getFaceTable()) {
auto transport = dynamic_cast<NetDeviceTransport*>(face.getTransport());
if (transport == nullptr)
continue;
Ptr<PointToPointNetDevice> nd1 = transport->GetNetDevice()->GetObject<PointToPointNetDevice>();
if (nd1 == nullptr)
continue;
Ptr<Channel> channel = nd1->GetChannel();
if (channel == nullptr)
continue;
Ptr<PointToPointChannel> ppChannel = DynamicCast<PointToPointChannel>(channel);
Ptr<NetDevice> nd2 = ppChannel->GetDevice(0);
if (nd2->GetNode() == node1)
nd2 = ppChannel->GetDevice(1);
if (nd2->GetNode() == node2) {
ObjectFactory errorFactory("ns3::RateErrorModel");
errorFactory.Set("ErrorUnit", StringValue("ERROR_UNIT_PACKET"));
errorFactory.Set("ErrorRate", DoubleValue(errorRate));
if (errorRate <= 0) {
errorFactory.Set("IsEnabled", BooleanValue(false));
}
nd1->SetAttribute("ReceiveErrorModel", PointerValue(errorFactory.Create<ErrorModel>()));
nd2->SetAttribute("ReceiveErrorModel", PointerValue(errorFactory.Create<ErrorModel>()));
return;
}
}
NS_FATAL_ERROR("There is no link to fail between the requested nodes");
}
void
LogComponentEnable (char const *name, enum LogLevel level)
{
ComponentList *components = GetComponentList ();
ComponentListI i;
for (i = components->begin ();
i != components->end ();
i++)
{
if (i->first.compare (name) == 0)
{
i->second->Enable (level);
return;
}
}
if (i == components->end())
{
// nothing matched
LogComponentPrintList();
NS_FATAL_ERROR ("Logging component \"" << name <<
"\" not found. See above for a list of available log components");
}
}
IpcsClassifierRecord::IpcsClassifierRecord (Tlv tlv)
{
NS_ASSERT_MSG (tlv.GetType () == CsParamVectorTlvValue::Packet_Classification_Rule, "Invalid TLV");
ClassificationRuleVectorTlvValue* rules = ((ClassificationRuleVectorTlvValue*)(tlv.PeekValue ()));
m_priority = 0;
m_index = 0;
m_tosLow = 0;
m_tosHigh = 0;
m_tosMask = 0;
m_cid = 0;
for (std::vector<Tlv*>::const_iterator iter = rules->Begin (); iter != rules->End (); ++iter)
{
switch ((*iter)->GetType ())
{
case ClassificationRuleVectorTlvValue::Priority:
{
m_priority = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case ClassificationRuleVectorTlvValue::ToS:
{
NS_FATAL_ERROR ("ToS Not implemented-- please implement and contribute a patch");
break;
}
case ClassificationRuleVectorTlvValue::Protocol:
{
ProtocolTlvValue * list = (ProtocolTlvValue *)(*iter)->PeekValue ();
for (std::vector<uint8_t>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddProtocol (*iter2);
}
break;
}
case ClassificationRuleVectorTlvValue::IP_src:
{
Ipv4AddressTlvValue * list = (Ipv4AddressTlvValue *)(*iter)->PeekValue ();
for (std::vector<Ipv4AddressTlvValue::ipv4Addr>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddSrcAddr ((*iter2).Address, (*iter2).Mask);
}
break;
}
case ClassificationRuleVectorTlvValue::IP_dst:
{
Ipv4AddressTlvValue * list = (Ipv4AddressTlvValue *)(*iter)->PeekValue ();
for (std::vector<Ipv4AddressTlvValue::ipv4Addr>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddDstAddr ((*iter2).Address, (*iter2).Mask);
}
break;
}
case ClassificationRuleVectorTlvValue::Port_src:
{
PortRangeTlvValue * list = (PortRangeTlvValue *)(*iter)->PeekValue ();
for (std::vector<PortRangeTlvValue::PortRange>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddSrcPortRange ((*iter2).PortLow, (*iter2).PortHigh);
}
break;
}
case ClassificationRuleVectorTlvValue::Port_dst:
{
PortRangeTlvValue * list = (PortRangeTlvValue *)(*iter)->PeekValue ();
for (std::vector<PortRangeTlvValue::PortRange>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddDstPortRange ((*iter2).PortLow, (*iter2).PortHigh);
}
break;
}
case ClassificationRuleVectorTlvValue::Index:
{
m_index = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
}
}
}
void
BlockAckManager::NotifyGotBlockAck (const CtrlBAckResponseHeader *blockAck, Mac48Address recipient)
{
NS_LOG_FUNCTION (this << blockAck << recipient);
uint16_t sequenceFirstLost = 0;
if (!blockAck->IsMultiTid ())
{
uint8_t tid = blockAck->GetTidInfo ();
if (ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::ESTABLISHED))
{
bool foundFirstLost = false;
AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));
PacketQueueI queueEnd = it->second.second.end ();
if (it->second.first.m_inactivityEvent.IsRunning ())
{
/* Upon reception of a block ack frame, the inactivity timer at the
originator must be reset.
For more details see section 11.5.3 in IEEE802.11e standard */
it->second.first.m_inactivityEvent.Cancel ();
Time timeout = MicroSeconds (1024 * it->second.first.GetTimeout ());
it->second.first.m_inactivityEvent = Simulator::Schedule (timeout,
&BlockAckManager::InactivityTimeout,
this,
recipient, tid);
}
if (blockAck->IsBasic ())
{
for (PacketQueueI queueIt = it->second.second.begin (); queueIt != queueEnd;)
{
if (blockAck->IsFragmentReceived ((*queueIt).hdr.GetSequenceNumber (),
(*queueIt).hdr.GetFragmentNumber ()))
{
queueIt = it->second.second.erase (queueIt);
}
else
{
if (!foundFirstLost)
{
foundFirstLost = true;
sequenceFirstLost = (*queueIt).hdr.GetSequenceNumber ();
(*it).second.first.SetStartingSequence (sequenceFirstLost);
}
m_retryPackets.push_back (queueIt);
queueIt++;
}
}
}
else if (blockAck->IsCompressed ())
{
for (PacketQueueI queueIt = it->second.second.begin (); queueIt != queueEnd;)
{
if (blockAck->IsPacketReceived ((*queueIt).hdr.GetSequenceNumber ()))
{
uint16_t currentSeq = (*queueIt).hdr.GetSequenceNumber ();
while (queueIt != queueEnd
&& (*queueIt).hdr.GetSequenceNumber () == currentSeq)
{
queueIt = it->second.second.erase (queueIt);
}
}
else
{
if (!foundFirstLost)
{
foundFirstLost = true;
sequenceFirstLost = (*queueIt).hdr.GetSequenceNumber ();
(*it).second.first.SetStartingSequence (sequenceFirstLost);
}
m_retryPackets.push_back (queueIt);
queueIt++;
}
}
}
uint16_t newSeq = m_txMiddle->GetNextSeqNumberByTidAndAddress (tid, recipient);
if ((foundFirstLost && !SwitchToBlockAckIfNeeded (recipient, tid, sequenceFirstLost))
|| (!foundFirstLost && !SwitchToBlockAckIfNeeded (recipient, tid, newSeq)))
{
it->second.first.SetState (OriginatorBlockAckAgreement::INACTIVE);
}
}
}
else
{
//NOT SUPPORTED FOR NOW
NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
}
}
void
LenaMimoTestCase::DoRun (void)
{
NS_LOG_FUNCTION (this << GetName ());
Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
Config::SetDefault ("ns3::LteAmc::AmcModel", EnumValue (LteAmc::PiroEW2010));
Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (m_useIdealRrc));
/**
* Initialize Simulation Scenario: 1 eNB and m_nUser UEs
*/
Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false));
Config::SetDefault ("ns3::PfFfMacScheduler::HarqEnabled", BooleanValue (false));
// lteHelper->SetSchedulerAttribute ("HarqEnabled", BooleanValue (false));
lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel"));
lteHelper->SetPathlossModelAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0));
lteHelper->SetPathlossModelAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));
lteHelper->SetPathlossModelAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));
// lteHelper->EnableLogComponents ();
// Create Nodes: eNodeB and UE
NodeContainer enbNodes;
NodeContainer ueNodes;
enbNodes.Create (1);
ueNodes.Create (1);
// Install Mobility Model
MobilityHelper mobility;
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (enbNodes);
BuildingsHelper::Install (enbNodes);
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (ueNodes);
BuildingsHelper::Install (ueNodes);
// Create Devices and install them in the Nodes (eNB and UE)
NetDeviceContainer enbDevs;
NetDeviceContainer ueDevs;
lteHelper->SetSchedulerType (m_schedulerType);
enbDevs = lteHelper->InstallEnbDevice (enbNodes);
ueDevs = lteHelper->InstallUeDevice (ueNodes);
// Attach a UE to a eNB
lteHelper->Attach (ueDevs, enbDevs.Get (0));
// Activate an EPS bearer
enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
EpsBearer bearer (q);
lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy ();
enbPhy->SetAttribute ("TxPower", DoubleValue (46.0));
enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0));
Ptr<MobilityModel> mmenb = enbNodes.Get (0)->GetObject<MobilityModel> ();
mmenb->SetPosition (Vector (0.0, 0.0, 30.0));
// Set UE's position and power
Ptr<MobilityModel> mmue = ueNodes.Get (0)->GetObject<MobilityModel> ();
mmue->SetPosition (Vector (m_dist, 0.0, 1.0));
Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (0)->GetObject<LteUeNetDevice> ();
Ptr<LteUePhy> uePhy = lteUeDev->GetPhy ();
uePhy->SetAttribute ("TxPower", DoubleValue (23.0));
uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0));
// need to allow for RRC connection establishment + SRS before enabling traces
lteHelper->EnableRlcTraces ();
lteHelper->EnableMacTraces ();
double simulationTime = 0.6;
double tolerance = 0.1;
uint8_t rnti = 1;
Ptr<LteEnbNetDevice> enbNetDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
PointerValue ptrval;
enbNetDev->GetAttribute ("FfMacScheduler", ptrval);
Ptr<PfFfMacScheduler> pfsched;
Ptr<RrFfMacScheduler> rrsched;
if (m_schedulerType.compare ("ns3::RrFfMacScheduler") == 0)
{
rrsched = ptrval.Get<RrFfMacScheduler> ();
if (rrsched == 0)
{
NS_FATAL_ERROR ("No RR Scheduler available");
}
Simulator::Schedule (Seconds (0.2), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 1);
Simulator::Schedule (Seconds (0.4), &RrFfMacScheduler::TransmissionModeConfigurationUpdate, rrsched, rnti, 2);
}
else if (m_schedulerType.compare ("ns3::PfFfMacScheduler") == 0)
{
pfsched = ptrval.Get<PfFfMacScheduler> ();
if (pfsched == 0)
{
NS_FATAL_ERROR ("No Pf Scheduler available");
}
Simulator::Schedule (Seconds (0.2), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 1);
Simulator::Schedule (Seconds (0.4), &PfFfMacScheduler::TransmissionModeConfigurationUpdate, pfsched, rnti, 2);
}
else
{
NS_FATAL_ERROR ("Scheduler not supported by this test");
}
Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats ();
rlcStats->SetAttribute ("EpochDuration", TimeValue (Seconds (0.1)));
NS_LOG_INFO (m_schedulerType << " MIMO test:");
double sampleTime = 0.199999; // at 0.2 RlcStats are reset
for (uint8_t j = 0; j < m_estThrDl.size (); j ++)
{
NS_LOG_INFO ("\t test with user at distance " << m_dist << " time " << sampleTime);
// get the imsi
uint64_t imsi = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetImsi ();
uint8_t lcId = 3;
Time t = Seconds (sampleTime);
Simulator::Schedule(t, &LenaMimoTestCase::GetRlcBufferSample, this, rlcStats, imsi, lcId);
sampleTime += 0.2;
}
Simulator::Stop (Seconds (simulationTime));
Simulator::Run ();
Simulator::Destroy ();
NS_LOG_INFO ("Check consistency");
for (uint8_t i = 0; i < m_estThrDl.size (); i++)
{
NS_LOG_INFO ("interval " << i + 1 << ": bytes rxed " << (double)m_dlDataRxed.at (i) << " ref " << m_estThrDl.at (i));
NS_TEST_ASSERT_MSG_EQ_TOL ((double)m_dlDataRxed.at (i) , m_estThrDl.at (i), m_estThrDl.at (i) * tolerance, " Unfair Throughput!");
}
}
void
FileHelper::WriteProbe (const std::string &typeId,
const std::string &path,
const std::string &probeTraceSource)
{
NS_LOG_FUNCTION (this << typeId << path << probeTraceSource);
std::string pathWithoutLastToken;
std::string lastToken;
// See if the path has any wildcards.
bool pathHasNoWildcards = path.find ("*") == std::string::npos;
// Remove the last token from the path.
size_t lastSlash = path.find_last_of ("/");
if (lastSlash == std::string::npos)
{
pathWithoutLastToken = path;
lastToken = "";
}
else
{
// Chop off up to last token.
pathWithoutLastToken = path.substr (0, lastSlash);
// Save the last token without the last slash.
lastToken = path.substr (lastSlash + 1, std::string::npos);
}
// See if there are any matches for the probe's path with the last
// token removed.
Config::MatchContainer matches = Config::LookupMatches (pathWithoutLastToken);
uint32_t matchCount = matches.GetN ();
// This is used to make the probe's context be unique.
std::string matchIdentifier;
/// This is used to indicate if multiple aggregators are needed.
bool onlyOneAggregator;
// Hook one or more probes and one or more aggregators together.
if (matchCount == 1 && pathHasNoWildcards)
{
// Connect the probe to the aggregator only once because there
// is only one matching config path. There is no need to find
// the wildcard matches because the passed in path has none.
matchIdentifier = "0";
onlyOneAggregator = true;
ConnectProbeToAggregator (typeId,
matchIdentifier,
path,
probeTraceSource,
m_outputFileNameWithoutExtension,
onlyOneAggregator);
}
else if (matchCount > 0)
{
// Handle all of the matches if there are more than one.
for (uint32_t i = 0; i < matchCount; i++)
{
// Set the match identifier.
std::ostringstream matchIdentifierStream;
matchIdentifierStream << i;
matchIdentifier = matchIdentifierStream.str ();
onlyOneAggregator = false;
// Construct the matched path and get the matches for each
// of the wildcards.
std::string wildcardSeparator = "-";
std::string matchedPath = matches.GetMatchedPath (i) + lastToken;
std::string wildcardMatches = GetWildcardMatches (path,
matchedPath,
wildcardSeparator);
// Connect the probe to the aggregator for this match.
ConnectProbeToAggregator (typeId,
matchIdentifier,
matchedPath,
probeTraceSource,
m_outputFileNameWithoutExtension + "-" + wildcardMatches,
onlyOneAggregator);
}
}
else
{
// There is a problem if there are no matching config paths.
NS_FATAL_ERROR ("Lookup of " << path << " got no matches");
}
}
void
FileHelper::ConnectProbeToAggregator (const std::string &typeId,
const std::string &matchIdentifier,
const std::string &path,
const std::string &probeTraceSource,
const std::string &outputFileNameWithoutExtension,
bool onlyOneAggregator)
{
NS_LOG_FUNCTION (this << typeId << matchIdentifier << path << probeTraceSource
<< outputFileNameWithoutExtension << onlyOneAggregator);
// Increment the total number of file probes that have been created.
m_fileProbeCount++;
// Create a unique name for this probe.
std::ostringstream probeNameStream;
probeNameStream << "FileProbe-" << m_fileProbeCount;
std::string probeName = probeNameStream.str ();
// Create a unique dataset context string for this probe.
std::string probeContext = probeName
+ "/" + matchIdentifier + "/" + probeTraceSource;
// Add the probe to the map of probes, which will keep the probe in
// memory after this function ends.
AddProbe (typeId, probeName, path);
// Because the callbacks to the probes' trace sources don't use the
// probe's context, a unique adaptor needs to be created for each
// probe context so that information is not lost.
AddTimeSeriesAdaptor (probeContext);
// Connect the probe to the adaptor.
if (m_probeMap[probeName].second == "ns3::DoubleProbe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkDouble,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::BooleanProbe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkBoolean,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::PacketProbe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkUinteger32,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::ApplicationPacketProbe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkUinteger32,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::Ipv4PacketProbe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkUinteger32,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::Ipv6PacketProbe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkUinteger32,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::Uinteger8Probe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkUinteger8,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::Uinteger16Probe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkUinteger16,
m_timeSeriesAdaptorMap[probeContext]));
}
else if (m_probeMap[probeName].second == "ns3::Uinteger32Probe")
{
m_probeMap[probeName].first->TraceConnectWithoutContext
(probeTraceSource,
MakeCallback (&TimeSeriesAdaptor::TraceSinkUinteger32,
m_timeSeriesAdaptorMap[probeContext]));
}
else
{
NS_FATAL_ERROR ("Unknown probe type " << m_probeMap[probeName].second << "; need to add support in the helper for this");
}
// Add the aggregator to the map of aggregators, which will keep the
// aggregator in memory after this function ends.
std::string outputFileName = outputFileNameWithoutExtension + ".txt";
AddAggregator (probeContext, outputFileName, onlyOneAggregator);
// Connect the adaptor to the aggregator.
std::string adaptorTraceSource = "Output";
m_timeSeriesAdaptorMap[probeContext]->TraceConnect
(adaptorTraceSource,
probeContext,
MakeCallback (&FileAggregator::Write2d,
m_aggregatorMap[probeContext]));
}
