A Discrete-Event Network Simulator
API
service-flow.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007,2008,2009 INRIA, UDcast
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Authors: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>
19  * Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
20  * <amine.ismail@UDcast.com>
21  */
22 
23 #include "service-flow.h"
24 #include "service-flow-record.h"
25 #include "ns3/simulator.h"
26 #include "wimax-tlv.h"
27 
28 namespace ns3 {
29 
31 {
32  InitValues ();
33  m_direction = direction;
35  m_record = new ServiceFlowRecord ();
36  m_sfid = 0;
37  m_connection = 0;
38  m_isEnabled = false;
39  m_isMulticast = false;
41 }
42 
44  : m_sfid (0),
45  m_direction (SF_DIRECTION_DOWN),
46  m_type (SF_TYPE_PROVISIONED),
47  m_connection (0),
48  m_isEnabled (false),
49  m_record (new ServiceFlowRecord ())
50 {
51  InitValues ();
52  m_isMulticast = false;
54 
55 }
56 
57 ServiceFlow::ServiceFlow (uint32_t sfid, Direction direction, Ptr<WimaxConnection> connection)
58 {
59  InitValues ();
60  m_record = new ServiceFlowRecord ();
61  m_isEnabled = false;
62  m_connection = connection;
63  m_connection->SetServiceFlow (this);
65  m_direction = direction;
66  m_sfid = sfid;
67  m_isMulticast = false;
69 }
70 
72 {
73  InitValues ();
74  m_connection = 0;
75  m_isEnabled = 0;
76  m_record = new ServiceFlowRecord ();
78  "Invalid TLV");
79 
80  SfVectorTlvValue * param;
81  param = (SfVectorTlvValue*)(tlv.PeekValue ());
82 
83  if (tlv.GetType () == Tlv::UPLINK_SERVICE_FLOW)
84  {
86  }
87  else
88  {
90  }
91 
92  for (std::vector<Tlv*>::const_iterator iter = param->Begin (); iter != param->End (); ++iter)
93  {
94  switch ((*iter)->GetType ())
95  {
97  {
98  m_sfid = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
99  break;
100  }
102  {
103  uint16_t cid = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
104  m_connection = CreateObject<WimaxConnection> (cid, Cid::TRANSPORT);
105  break;
106  }
108  {
109  m_qosParamSetType = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
110  break;
111  }
113  {
114  m_trafficPriority = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
115  break;
116  }
118  {
119  m_maxSustainedTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
120  break;
121  }
123  {
124  m_maxTrafficBurst = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
125  break;
126  }
128  {
129  m_minReservedTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
130  break;
131  }
133  {
134  m_minTolerableTrafficRate = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
135  break;
136  }
138  {
139  m_schedulingType = (ServiceFlow::SchedulingType)((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
140  break;
141  }
143  {
144  m_requestTransmissionPolicy = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
145  break;
146  }
148  {
149  m_toleratedJitter = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
150  break;
151  }
153  {
154  m_maximumLatency = ((U32TlvValue*)((*iter)->PeekValue ()))->GetValue ();
155  break;
156  }
158  {
159  m_fixedversusVariableSduIndicator = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
160  break;
161  }
163  {
164  m_csSpecification = (enum CsSpecification)(((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ());
165  break;
166  }
167 
169  {
171  break;
172  }
173 
174  }
175  }
176  m_isMulticast = false;
178 }
179 
181 {
182  if (m_record != 0)
183  {
184  delete m_record;
185  m_record = 0;
186  }
187  m_connection = 0;
188 }
189 
190 void
192 {
193  m_direction = direction;
194 }
195 
198 {
199  return m_direction;
200 }
201 
202 void
204 {
205  m_type = type;
206 }
207 
210 {
211  return m_type;
212 }
213 
214 void
216 {
217  m_connection = connection;
218  m_connection->SetServiceFlow (this);
219 }
220 
223 {
224  return m_connection;
225 }
226 
227 void
229 {
230  m_isEnabled = isEnabled;
231 }
232 
233 bool
235 {
236  return m_isEnabled;
237 }
238 
239 void
241 {
242  m_record = record;
243 }
244 
247 {
248  return m_record;
249 }
250 
253 {
254  if (!m_connection)
255  {
256  return 0;
257  }
258  return m_connection->GetQueue ();
259 }
260 
263 {
264  return m_schedulingType;
265 }
266 
267 bool
269 {
270  if (!m_connection)
271  {
272  return false;
273  }
274  return m_connection->HasPackets ();
275 }
276 
277 bool
279 {
280  if (!m_connection)
281  {
282  return false;
283  }
284  return m_connection->HasPackets (packetType);
285 }
286 
287 void
289 {
290  GenericMacHeader hdr;
291  Time timeStamp;
292  Ptr<Packet> packet;
293  Time currentTime = Simulator::Now ();
294  if (m_connection)
295  {
296  while (m_connection->HasPackets ())
297  {
298  packet = m_connection->GetQueue ()->Peek (hdr, timeStamp);
299 
300  if (currentTime - timeStamp > MilliSeconds (GetMaximumLatency ()))
301  {
302  m_connection->Dequeue ();
303  }
304  else
305  {
306  break;
307  }
308  }
309  }
310 }
311 
312 void
314 {
315 }
316 // ==============================================================================
317 
318 
319 uint32_t
321 {
322  return m_sfid;
323 }
324 uint16_t
326 {
327  if (m_connection == 0)
328  {
329  return 0;
330  }
331  return m_connection->GetCid ().GetIdentifier ();
332 }
333 std::string
335 {
336  return m_serviceClassName;
337 }
338 uint8_t
340 {
341  return m_qosParamSetType;
342 }
343 uint8_t
345 {
346  return m_trafficPriority;
347 }
348 uint32_t
350 {
352 }
353 uint32_t
355 {
356  return m_maxTrafficBurst;
357 }
358 uint32_t
360 {
362 }
363 uint32_t
365 {
367 }
368 enum
370 {
371  return m_schedulingType;
372 }
373 uint32_t
375 {
377 }
378 uint32_t
380 {
381  return m_toleratedJitter;
382 }
383 uint32_t
385 {
386  return m_maximumLatency;
387 }
388 uint8_t
390 {
392 }
393 uint8_t
395 {
396  return m_sduSize;
397 }
398 uint16_t
400 {
401  return m_targetSAID;
402 }
403 uint8_t
405 {
406  return m_arqEnable;
407 }
408 uint16_t
410 {
411  return m_arqWindowSize;
412 }
413 uint16_t
415 {
416  return m_arqRetryTimeoutTx;
417 }
418 uint16_t
420 {
421  return m_arqRetryTimeoutRx;
422 }
423 
424 uint16_t
426 {
427  return m_arqBlockLifeTime;
428 }
429 uint16_t
431 {
432  return m_arqSyncLoss;
433 }
434 uint8_t
436 {
437  return m_arqDeliverInOrder;
438 }
439 uint16_t
441 {
442  return m_arqPurgeTimeout;
443 }
444 uint16_t
446 {
447  return m_arqBlockSize;
448 }
449 enum
451 {
452  return m_csSpecification;
453 }
454 CsParameters
456 {
458 }
459 uint16_t
461 {
463 }
464 uint16_t
466 {
468 }
469 
470 bool
472 {
473  return m_isMulticast;
474 }
476 ServiceFlow::GetModulation (void) const
477 {
478  return m_modulationType;
479 }
480 
481 
482 // ==============================================================================
483 
484 void
485 ServiceFlow::SetSfid (uint32_t sfid)
486 {
487  m_sfid = sfid;
488 }
489 void
491 {
492  m_serviceClassName = name;
493 }
494 void
496 {
497  m_qosParamSetType = type;
498 }
499 void
501 {
502  m_trafficPriority = priority;
503 }
504 void
505 ServiceFlow::SetMaxSustainedTrafficRate (uint32_t maxSustainedRate)
506 {
507  m_maxSustainedTrafficRate = maxSustainedRate;
508 }
509 void
510 ServiceFlow::SetMaxTrafficBurst (uint32_t maxTrafficBurst)
511 {
512  m_maxTrafficBurst = maxTrafficBurst;
513 }
514 void
516 {
517  m_minReservedTrafficRate = minResvRate;
518 }
519 void
521 {
522  m_minTolerableTrafficRate = minJitter;
523 }
524 void
526 {
527  m_schedulingType = schedType;
528 }
529 void
531 {
533 }
534 void
536 {
537  m_toleratedJitter = jitter;
538 }
539 void
540 ServiceFlow::SetMaximumLatency (uint32_t MaximumLatency)
541 {
542  m_maximumLatency = MaximumLatency;
543 }
544 void
546 {
547  m_fixedversusVariableSduIndicator = sduIndicator;
548 }
549 void
550 ServiceFlow::SetSduSize (uint8_t sduSize)
551 {
552  m_sduSize = sduSize;
553 }
554 void
555 ServiceFlow::SetTargetSAID (uint16_t targetSaid)
556 {
557  m_targetSAID = targetSaid;
558 }
559 void
560 ServiceFlow::SetArqEnable (uint8_t arqEnable)
561 {
562  m_arqEnable = arqEnable;
563 }
564 void
565 ServiceFlow::SetArqWindowSize (uint16_t arqWindowSize)
566 {
567  m_arqWindowSize = arqWindowSize;
568 }
569 void
571 {
573 }
574 void
576 {
578 }
579 void
581 {
582  m_arqBlockLifeTime = lifeTime;
583 }
584 void
585 ServiceFlow::SetArqSyncLoss (uint16_t syncLoss)
586 {
587  m_arqSyncLoss = syncLoss;
588 }
589 void
591 {
592  m_arqDeliverInOrder = inOrder;
593 }
594 void
596 {
598 }
599 void
601 {
602  m_arqBlockSize = size;
603 }
604 void
606 {
607  m_csSpecification = spec;
608 }
609 void
611 {
612  m_convergenceSublayerParam = csparam;
613 }
614 void
615 ServiceFlow::SetUnsolicitedGrantInterval (uint16_t unsolicitedGrantInterval)
616 {
617  m_unsolicitedGrantInterval = unsolicitedGrantInterval;
618 }
619 void
620 ServiceFlow::SetUnsolicitedPollingInterval (uint16_t unsolicitedPollingInterval)
621 {
622  m_unsolicitedPollingInterval = unsolicitedPollingInterval;
623 }
624 void
625 ServiceFlow::SetIsMulticast (bool isMulticast)
626 {
627  m_isMulticast = isMulticast;
628 }
629 void
631 {
632  m_modulationType = modulationType;
633 }
634 
635 void
637 {
638  m_sfid = 0;
639  m_serviceClassName = "";
640  m_qosParamSetType = 0;
641  m_trafficPriority = 0;
643  m_maxTrafficBurst = 0;
648  m_toleratedJitter = 0;
649  m_maximumLatency = 0;
651  m_sduSize = 0;
652  m_targetSAID = 0;
653  m_arqEnable = 0;
654  m_arqWindowSize = 0;
660  m_arqBlockLifeTime = 0;
661  m_arqSyncLoss = 0;
663  m_arqPurgeTimeout = 0;
664  m_arqBlockSize = 0;
667  m_isMulticast = false;
669 }
670 
671 void
673 {
686  m_sduSize = sf.GetSduSize ();
687  m_targetSAID = sf.GetTargetSAID ();
688  m_arqEnable = sf.GetArqEnable ();
696  m_direction = sf.GetDirection ();
699 }
700 
702 {
703  m_sfid = sf.GetSfid ();
716  m_sduSize = sf.GetSduSize ();
717  m_targetSAID = sf.GetTargetSAID ();
718  m_arqEnable = sf.GetArqEnable ();
726  m_direction = sf.GetDirection ();
727  m_type = sf.GetType ();
728  m_connection = sf.GetConnection ();
729  m_isEnabled = sf.GetIsEnabled ();
730  m_record = new ServiceFlowRecord ();
731  (*m_record) = (*sf.GetRecord ());
734 }
735 
736 ServiceFlow &
738 {
739 
740  m_sfid = o.GetSfid ();
753  m_sduSize = o.GetSduSize ();
755  m_arqEnable = o.GetArqEnable ();
763  m_direction = o.GetDirection ();
764  m_type = o.GetType ();
766  m_isEnabled = o.GetIsEnabled ();
769  if (m_record != 0)
770  {
771  delete m_record;
772  }
773 
774  m_record = new ServiceFlowRecord ();
775 
776  (*m_record) = (*o.GetRecord ());
777  return *this;
778 }
779 
780 char*
782 {
783  switch (m_schedulingType)
784  {
785  case SF_TYPE_UGS:
786  return (char*) "UGS";
787  break;
788  case SF_TYPE_RTPS:
789  return (char*) "rtPS";
790  break;
791  case SF_TYPE_NRTPS:
792  return (char*) "nrtPS";
793  break;
794  case SF_TYPE_BE:
795  return (char*) "BE";
796  break;
797  default:
798  NS_FATAL_ERROR ("Invalid scheduling type");
799  }
800  return 0;
801 }
802 
803 Tlv
804 ServiceFlow::ToTlv (void) const
805 {
806  SfVectorTlvValue tmpSfVector;
807  tmpSfVector.Add (Tlv (SfVectorTlvValue::SFID, 4, U32TlvValue (m_sfid)));
808  tmpSfVector.Add (Tlv (SfVectorTlvValue::CID, 2, U16TlvValue (GetCid ())));
820  1,
822  tmpSfVector.Add (Tlv (SfVectorTlvValue::SDU_Size, 1, U8TlvValue (m_sduSize)));
825  tmpSfVector.Add (m_convergenceSublayerParam.ToTlv ());
827  {
828  return Tlv (Tlv::UPLINK_SERVICE_FLOW, tmpSfVector.GetSerializedSize (), tmpSfVector);
829  }
830  else
831  {
832  return Tlv (Tlv::DOWNLINK_SERVICE_FLOW, tmpSfVector.GetSerializedSize (), tmpSfVector);
833  }
834 }
835 
836 bool
838  Ipv4Address dstAddress,
839  uint16_t srcPort,
840  uint16_t dstPort,
841  uint8_t proto) const
842 {
844  dstAddress,
845  srcPort,
846  dstPort,
847  proto);
848 }
849 } // namespace ns3
@ TRANSPORT
Definition: cid.h:47
CsParameters class.
Definition: cs-parameters.h:36
Tlv ToTlv(void) const
creates a tlv from the classifier record
IpcsClassifierRecord GetPacketClassifierRule(void) const
This class implements the Generic mac Header as described by IEEE Standard for Local and metropolitan...
bool CheckMatch(Ipv4Address srcAddress, Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const
check if a packets can be used with this classifier
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
HeaderType
Header type enumeration.
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:74
This class implements service flows as described by the IEEE-802.16 standard.
Definition: service-flow.h:40
uint8_t GetArqDeliverInOrder(void) const
Get ARQ deliver in order.
uint16_t m_targetSAID
traget SAID
Definition: service-flow.h:569
uint32_t m_requestTransmissionPolicy
request transmission policy
Definition: service-flow.h:564
enum WimaxPhy::ModulationType GetModulation(void) const
Get modulation.
void SetTargetSAID(uint16_t targetSaid)
Set target SAID.
void SetRequestTransmissionPolicy(uint32_t policy)
Set request transmission policy.
uint16_t m_arqBlockSize
ARQ block size.
Definition: service-flow.h:578
enum WimaxPhy::ModulationType m_modulationType
modulation type
Definition: service-flow.h:588
void SetSfid(uint32_t sfid)
Set SFID.
enum CsSpecification m_csSpecification
CS specification.
Definition: service-flow.h:579
std::string m_serviceClassName
service class name
Definition: service-flow.h:556
uint32_t m_toleratedJitter
tolerated jitter
Definition: service-flow.h:565
uint16_t GetArqRetryTimeoutTx(void) const
Get ARQ retry timeout transmit.
enum Type GetType(void) const
Get type of service flow.
void SetArqEnable(uint8_t arqEnable)
Set ARQ enable.
void SetArqBlockSize(uint16_t size)
Set ARQ block size.
enum ServiceFlow::SchedulingType m_schedulingType
scheduling type
Definition: service-flow.h:563
uint32_t GetMinReservedTrafficRate(void) const
Get minimum reserved traffic rate.
enum ServiceFlow::SchedulingType GetServiceSchedulingType(void) const
Get service scheduling type.
uint8_t GetArqEnable(void) const
Get ARQ enable.
void SetServiceClassName(std::string name)
Set service class name.
uint8_t GetSduSize(void) const
Get SDU size.
uint32_t m_maximumLatency
maximum latency
Definition: service-flow.h:566
uint32_t m_minTolerableTrafficRate
minimum tolerable traffic rate
Definition: service-flow.h:562
uint16_t GetUnsolicitedPollingInterval(void) const
Get unsolicited polling interval.
uint16_t m_arqBlockLifeTime
ARQ block life time.
Definition: service-flow.h:574
uint16_t GetArqRetryTimeoutRx(void) const
Get ARQ retry timeout receive.
uint16_t GetUnsolicitedGrantInterval(void) const
Get unsolicited grant interval.
uint16_t m_unsolicitedGrantInterval
unsolicited grant interval
Definition: service-flow.h:581
void SetType(enum Type type)
Set type of service flow.
CsParameters m_convergenceSublayerParam
convergence sublayer parameters
Definition: service-flow.h:580
bool m_isEnabled
is enabled?
Definition: service-flow.h:586
std::string GetServiceClassName() const
Get service class name.
uint8_t GetFixedversusVariableSduIndicator(void) const
Get fixed versus varaiable SDU indicator.
uint16_t m_arqRetryTimeoutTx
ARQ retry timeout transmit.
Definition: service-flow.h:572
uint8_t m_trafficPriority
traffic priority
Definition: service-flow.h:558
uint32_t m_minReservedTrafficRate
minimum reserved traffic rate
Definition: service-flow.h:561
Ptr< WimaxConnection > m_connection
connection
Definition: service-flow.h:585
void SetMaxTrafficBurst(uint32_t maxTrafficBurst)
Set maximum traffic burst.
void SetArqSyncLoss(uint16_t syncLoss)
Set ARQ sync loss.
void SetModulation(enum WimaxPhy::ModulationType modulationType)
Set modulation.
uint32_t m_maxSustainedTrafficRate
maximum sustained traffic rate
Definition: service-flow.h:559
uint16_t GetArqBlockSize(void) const
Get ARQ block size.
void SetMaximumLatency(uint32_t MaximumLatency)
Set maximum latency.
enum Direction GetDirection(void) const
Get direction.
uint8_t m_arqDeliverInOrder
ARQ deliver in order.
Definition: service-flow.h:576
Ptr< WimaxMacQueue > GetQueue(void) const
Get pointer to queue.
bool HasPackets(void) const
Check if packets are present.
void SetQosParamSetType(uint8_t type)
Set QOS parameter set type.
uint32_t m_maxTrafficBurst
maximum traffic burst
Definition: service-flow.h:560
enum ServiceFlow::SchedulingType GetSchedulingType(void) const
Get scheduling type.
uint16_t GetTargetSAID(void) const
Get target SAID.
uint32_t GetMaxTrafficBurst(void) const
Get max traffic burst.
void SetCsSpecification(enum CsSpecification spec)
Set CS specification.
uint16_t m_unsolicitedPollingInterval
unsolicited polling interval
Definition: service-flow.h:582
uint8_t m_qosParamSetType
QOS parameter type.
Definition: service-flow.h:557
SchedulingType
section 11.13.11 Service flow scheduling type, page 701
Definition: service-flow.h:59
ServiceFlow()
default constructor
Definition: service-flow.cc:43
uint16_t m_arqSyncLoss
ARQ sync loss.
Definition: service-flow.h:575
void SetArqWindowSize(uint16_t arqWindowSize)
Set ARQ retry timeout transmit.
void SetConvergenceSublayerParam(CsParameters csparam)
Set convergence sublayer parameters.
uint8_t GetQosParamSetType(void) const
Get QOS parameter set type.
uint16_t GetArqPurgeTimeout(void) const
Get ARQ purge timeout.
void SetSduSize(uint8_t sduSize)
Set SDU size.
void SetRecord(ServiceFlowRecord *record)
Set service flow record.
bool m_isMulticast
is multicast?
Definition: service-flow.h:587
void SetArqPurgeTimeout(uint16_t timeout)
Set ARQ purge timeout.
uint32_t GetMinTolerableTrafficRate(void) const
Get minimum tolerable traffic rate.
uint16_t GetArqBlockLifeTime(void) const
Get ARQ block lifetime.
uint16_t m_arqPurgeTimeout
ARQ purge timeout.
Definition: service-flow.h:577
char * GetSchedulingTypeStr(void) const
Get scheduling type string.
Type
Type enumeration.
Definition: service-flow.h:51
uint8_t GetTrafficPriority(void) const
Get traffic priority.
void SetTrafficPriority(uint8_t priority)
Set traffic priority.
ServiceFlowRecord * m_record
service flow record
Definition: service-flow.h:590
ServiceFlowRecord * GetRecord(void) const
Get service flow record.
Ptr< WimaxConnection > GetConnection(void) const
Can return a null connection is this service flow has not been associated yet to a connection.
void SetArqBlockLifeTime(uint16_t lifeTime)
Set ARQ block lifetime.
uint16_t GetCid(void) const
Get CID.
void CopyParametersFrom(ServiceFlow sf)
Copy parameters from another service flow.
void SetMinTolerableTrafficRate(uint32_t minJitter)
Set minimum tolerable traffic rate.
void InitValues(void)
Initial values.
void CleanUpQueue(void)
shall be called only by BS
uint16_t m_arqWindowSize
ARQ window size.
Definition: service-flow.h:571
void SetIsMulticast(bool isMulticast)
Set is multicast.
bool GetIsEnabled(void) const
Get is enabled flag.
void SetArqRetryTimeoutTx(uint16_t timeout)
Set ARQ retry timeout transmit.
uint8_t m_arqEnable
ARQ enable.
Definition: service-flow.h:570
uint8_t m_fixedversusVariableSduIndicator
fixed versus variable SDI indicator
Definition: service-flow.h:567
CsParameters GetConvergenceSublayerParam(void) const
Get convergence sublayer.
uint32_t GetMaximumLatency(void) const
Get maximum latency.
void SetToleratedJitter(uint32_t jitter)
Set tolerated jitter.
void SetUnsolicitedGrantInterval(uint16_t unsolicitedGrantInterval)
Set unsolicied grant interval.
uint8_t m_sduSize
SDU size.
Definition: service-flow.h:568
uint16_t GetArqWindowSize(void) const
Get ARQ retry timeout transmit.
void SetArqDeliverInOrder(uint8_t inOrder)
Set ARQ deliver in order.
bool GetIsMulticast(void) const
Get is multicast.
uint16_t m_arqRetryTimeoutRx
ARQ retry timeout receive.
Definition: service-flow.h:573
void SetServiceSchedulingType(enum ServiceFlow::SchedulingType schedType)
Set service scheduling type.
void SetArqRetryTimeoutRx(uint16_t timeout)
Set ARQ retry timeout receive.
enum CsSpecification GetCsSpecification(void) const
Get CS specification.
void SetUnsolicitedPollingInterval(uint16_t unsolicitedPollingInterval)
Set unsolicited polling interval.
void SetMinReservedTrafficRate(uint32_t minResvRate)
Set minimum reserved traffic rate.
CsSpecification
section 11.13.19.2 CS parameter encoding rules, page 707
Definition: service-flow.h:70
bool CheckClassifierMatch(Ipv4Address srcAddress, Ipv4Address dstAddress, uint16_t srcPort, uint16_t dstPort, uint8_t proto) const
Tlv ToTlv(void) const
creates a TLV from this service flow
Direction
Direction enumeration.
Definition: service-flow.h:44
uint32_t GetToleratedJitter(void) const
Get tolerated jitter.
uint32_t m_sfid
SFID.
Definition: service-flow.h:555
uint16_t GetArqSyncLoss(void) const
Get ARQ sync loss.
ServiceFlow & operator=(ServiceFlow const &o)
assignment operator
void SetFixedversusVariableSduIndicator(uint8_t sduIndicator)
Set fixed versus variable SDU indicator.
uint32_t GetRequestTransmissionPolicy(void) const
Get request transmission policy.
Direction m_direction
direction
Definition: service-flow.h:583
void SetMaxSustainedTrafficRate(uint32_t maxSustainedRate)
Set max sustained traffic rate.
void PrintQoSParameters(void) const
Print QOS parameters.
uint32_t GetMaxSustainedTrafficRate(void) const
Get max sustained traffic rate.
uint32_t GetSfid(void) const
Get SFID.
void SetConnection(Ptr< WimaxConnection > connection)
Set connection.
void SetIsEnabled(bool isEnabled)
Set is enabled flag.
void SetDirection(enum Direction direction)
Set direction.
this class implements a structure to manage some parameters and statistics related to a service flow
SfVectorTlvValue class.
Definition: wimax-tlv.h:329
@ Fixed_length_versus_Variable_length_SDU_Indicator
Definition: wimax-tlv.h:349
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:195
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
This class implements the Type-Len-Value structure channel encodings as described by "IEEE Standard f...
Definition: wimax-tlv.h:84
uint8_t GetType(void) const
Get type value.
Definition: wimax-tlv.cc:214
TlvValue * PeekValue(void)
Peek value.
Definition: wimax-tlv.cc:224
@ UPLINK_SERVICE_FLOW
Definition: wimax-tlv.h:93
@ DOWNLINK_SERVICE_FLOW
Definition: wimax-tlv.h:92
U16TlvValue class.
Definition: wimax-tlv.h:210
U32TlvValue class.
Definition: wimax-tlv.h:249
U8TlvValue class.
Definition: wimax-tlv.h:171
Iterator End() const
End iterator.
Definition: wimax-tlv.cc:278
Iterator Begin() const
Begin iterator.
Definition: wimax-tlv.cc:272
void Add(const Tlv &val)
Add a TLV.
Definition: wimax-tlv.cc:284
virtual uint32_t GetSerializedSize(void) const
Get serialized size in bytes.
Definition: wimax-tlv.cc:251
ModulationType
ModulationType enumeration.
Definition: wimax-phy.h:52
@ MODULATION_TYPE_QPSK_12
Definition: wimax-phy.h:54
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1252
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::Time timeout