This file is indexed.

/usr/include/ns3.26/ns3/ul-job.h is in libns3-dev 3.26+dfsg-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author:  Juliana Freitag Borin, Flavio Kubota and Nelson L.
 * S. da Fonseca - wimaxgroup@lrc.ic.unicamp.br
 */

#ifndef UL_JOB_H
#define UL_JOB_H

#include <stdint.h>
#include "ns3/header.h"
#include "ss-record.h"
#include "service-flow.h"
#include "service-flow-record.h"

namespace ns3 {

class SSRecord;
class ServiceFlow;

enum ReqType
{
  DATA, UNICAST_POLLING
};

/**
 * \ingroup wimax
 * \brief this class implements a structure to compute the priority of service flows
 */
class UlJob : public Object
{
public:
  enum JobPriority
  {
    LOW, INTERMEDIATE, HIGH
  };
  UlJob (void);
  virtual ~UlJob (void);
  SSRecord *
  GetSsRecord (void);
  void SetSsRecord (SSRecord* ssRecord);
  enum ServiceFlow::SchedulingType GetSchedulingType (void);
  void SetSchedulingType (ServiceFlow::SchedulingType schedulingType);
  ServiceFlow *
  GetServiceFlow (void);
  void SetServiceFlow (ServiceFlow *serviceFlow);

  ReqType GetType (void);
  void SetType (ReqType type);

  Time GetReleaseTime (void);
  void SetReleaseTime (Time releaseTime);

  Time GetPeriod (void);
  void SetPeriod (Time period);

  Time GetDeadline (void);
  void SetDeadline (Time deadline);

  uint32_t GetSize (void);
  void SetSize (uint32_t size);

private:
  friend bool operator == (const UlJob &a, const UlJob &b);

  Time m_releaseTime; /* The time after which the job can be processed*/
  Time m_period; /* For periodic jobs*/
  Time m_deadline; /* Request should be satisfied by this time */
  uint32_t m_size; /* Number of minislots requested */
  enum ServiceFlow::SchedulingType m_schedulingType; /* Scheduling type of flow */

  uint8_t m_flag; /* To delete or not..*/
  uint8_t m_retryCount;
  double m_ugsJitter; /* The jitter in the grant, valid only for UGS flows */
  int m_jitterSamples;
  double m_last_jitterCalTime; /* Last time avg jitter was calculated */

  SSRecord *m_ssRecord; /* Pointer to SSRecord */

  ReqType m_type; /* Type of request, DATA or Unicast req slots */
  ServiceFlow *m_serviceFlow;

};


class PriorityUlJob : public Object
{

  /**
   * \brief this class implements an auxiliar struct to compute the priority of the rtPS and nrtPS in
   * the intermediate queue
   */
public:
  PriorityUlJob ();
  int GetPriority (void);
  void SetPriority (int priority);

  Ptr<UlJob>
  GetUlJob (void);
  void SetUlJob (Ptr<UlJob> job);

private:
  int m_priority;
  Ptr<UlJob> m_job;
};

struct SortProcess : public std::binary_function<PriorityUlJob*, PriorityUlJob*, bool>
{
  bool operator () (PriorityUlJob& left, PriorityUlJob& right) const
  { // return true if left is logically less then right for given comparison
    if (left.GetPriority () < right.GetPriority ())
      {
        return true;
      }
    else if (left.GetPriority () == right.GetPriority ())
      {
        int32_t leftBacklogged = left.GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
        int32_t rightBacklogged = left.GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
        if (leftBacklogged <= rightBacklogged)
          {
            return true;
          }
        else
          {
            return false;
          }
      }
    else
      {
        return false;
      }
  }
};

struct SortProcessPtr: public std::binary_function< Ptr<PriorityUlJob>, Ptr<PriorityUlJob>, bool>
{
  bool operator () (Ptr<PriorityUlJob>& left, Ptr<PriorityUlJob>& right) const
  { //return true if left is logically less then right for given comparison
    if (left->GetPriority () < right->GetPriority ())
      {
        return true;
      }
    else if (left->GetPriority () == right->GetPriority ())
      {
        int32_t leftBacklogged = left->GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
        int32_t rightBacklogged = left->GetUlJob ()->GetServiceFlow ()->GetRecord ()->GetBacklogged ();
        if (leftBacklogged <= rightBacklogged)
          {
            return true;
          }
        else
          {
            return false;
          }
      }
    else
      {
        return false;
      }
  }
};


} // namespace ns3

#endif /* UL_JOB_H */