View | Details | Raw Unified | Return to bug 2009
Collapse All | Expand All

(-)a/example/ccnx/dce-wifi-ccnx.cc (-1 lines)
 Lines 35-41    Link Here 
35
#include "ns3/dce-module.h"
35
#include "ns3/dce-module.h"
36
36
37
#include "ns3/rectangle.h"
37
#include "ns3/rectangle.h"
38
#include "ns3/random-variable.h"
39
38
40
39
41
40
(-)a/helper/dce-manager-helper.cc (-4 / +3 lines)
 Lines 5-11    Link Here 
5
#include "task-scheduler.h"
5
#include "task-scheduler.h"
6
#include "task-manager.h"
6
#include "task-manager.h"
7
#include "loader-factory.h"
7
#include "loader-factory.h"
8
#include "ns3/random-variable.h"
8
#include "ns3/random-variable-stream.h"
9
#include "ns3/uinteger.h"
9
#include "ns3/uinteger.h"
10
#include "ns3/string.h"
10
#include "ns3/string.h"
11
#include "ns3/config.h"
11
#include "ns3/config.h"
 Lines 24-31    Link Here 
24
24
25
namespace ns3 {
25
namespace ns3 {
26
26
27
UniformVariable g_firstPid;
28
29
NS_OBJECT_ENSURE_REGISTERED (DceManagerHelper);
27
NS_OBJECT_ENSURE_REGISTERED (DceManagerHelper);
30
28
31
TypeId
29
TypeId
 Lines 111-117    Link Here 
111
109
112
      taskManager->SetScheduler (scheduler);
110
      taskManager->SetScheduler (scheduler);
113
      taskManager->SetDelayModel (delay);
111
      taskManager->SetDelayModel (delay);
114
      manager->SetAttribute ("FirstPid", UintegerValue (g_firstPid.GetInteger (0, 0xffff)));
112
      Ptr<UniformRandomVariable> uv = CreateObject<UniformRandomVariable> ();
113
      manager->SetAttribute ("FirstPid", UintegerValue (uv->GetInteger (0, 0xffff)));
115
      Ptr<Node> node = *i;
114
      Ptr<Node> node = *i;
116
      node->AggregateObject (taskManager);
115
      node->AggregateObject (taskManager);
117
      node->AggregateObject (loader);
116
      node->AggregateObject (loader);
(-)a/model/dce-manager.cc (-2 / +7 lines)
 Lines 39-44    Link Here 
39
#include "ns3/ptr.h"
39
#include "ns3/ptr.h"
40
#include "ns3/uinteger.h"
40
#include "ns3/uinteger.h"
41
#include "ns3/boolean.h"
41
#include "ns3/boolean.h"
42
#include "ns3/double.h"
42
#include "ns3/trace-source-accessor.h"
43
#include "ns3/trace-source-accessor.h"
43
#include "ns3/enum.h"
44
#include "ns3/enum.h"
44
#include "file-usage.h"
45
#include "file-usage.h"
 Lines 349-355    Link Here 
349
  process->stdinFilename = stdinfilename;
350
  process->stdinFilename = stdinfilename;
350
351
351
  //"seeding" random variable
352
  //"seeding" random variable
352
  process->rndVarible = UniformVariable (0, RAND_MAX);
353
  process->rndVariable = CreateObject<UniformRandomVariable> ();
354
  process->rndVariable->SetAttribute ("Min", DoubleValue (0));
355
  process->rndVariable->SetAttribute ("Max", DoubleValue (RAND_MAX));
353
356
354
  process->nodeId = UtilsGetNodeId ();
357
  process->nodeId = UtilsGetNodeId ();
355
358
 Lines 638-644    Link Here 
638
  clone->penvp = thread->process->penvp;
641
  clone->penvp = thread->process->penvp;
639
642
640
  //"seeding" random variable
643
  //"seeding" random variable
641
  clone->rndVarible = UniformVariable (0, RAND_MAX);
644
  clone->rndVariable = CreateObject<UniformRandomVariable> ();
645
  clone->rndVariable->SetAttribute ("Min", DoubleValue (0));
646
  clone->rndVariable->SetAttribute ("Max", DoubleValue (RAND_MAX));
642
  m_processes[clone->pid] = clone;
647
  m_processes[clone->pid] = clone;
643
  Thread *cloneThread = CreateThread (clone);
648
  Thread *cloneThread = CreateThread (clone);
644
649
(-)a/model/dce-node-context.cc (-3 / +6 lines)
 Lines 25-30    Link Here 
25
#include "ns3/node.h"
25
#include "ns3/node.h"
26
#include "ns3/node-list.h"
26
#include "ns3/node-list.h"
27
#include "ns3/names.h"
27
#include "ns3/names.h"
28
#include "ns3/double.h"
28
#include "utils.h"
29
#include "utils.h"
29
#include <string.h>
30
#include <string.h>
30
#include "process.h"
31
#include "process.h"
 Lines 51-58    Link Here 
51
}
52
}
52
DceNodeContext::DceNodeContext ()
53
DceNodeContext::DceNodeContext ()
53
{
54
{
54
  m_randomCtx = NormalVariable (0, 2 ^ 32 - 1);
55
  m_randomCtx = CreateObject<NormalRandomVariable> ();
55
  m_rndBuffer = m_randomCtx.GetInteger ();
56
  m_randomCtx->SetAttribute ("Mean", DoubleValue (0)); 
57
  m_randomCtx->SetAttribute ("Variance", DoubleValue (2 ^ 32 - 1)); 
58
  m_rndBuffer = m_randomCtx->GetInteger ();
56
  m_rndOffset = 0;
59
  m_rndOffset = 0;
57
}
60
}
58
61
 Lines 127-133    Link Here 
127
  if (m_rndOffset >= 4)
130
  if (m_rndOffset >= 4)
128
    {
131
    {
129
      m_rndOffset = 0;
132
      m_rndOffset = 0;
130
      m_rndBuffer = m_randomCtx.GetInteger ();
133
      m_rndBuffer = m_randomCtx->GetInteger ();
131
    }
134
    }
132
  return v;
135
  return v;
133
}
136
}
(-)a/model/dce-node-context.h (-2 / +2 lines)
 Lines 27-33    Link Here 
27
#include "ns3/traced-callback.h"
27
#include "ns3/traced-callback.h"
28
#include "ns3/simulator.h"
28
#include "ns3/simulator.h"
29
#include <sys/utsname.h>
29
#include <sys/utsname.h>
30
#include "ns3/random-variable.h"
30
#include "ns3/random-variable-stream.h"
31
31
32
extern "C" struct Libc;
32
extern "C" struct Libc;
33
33
 Lines 62-68    Link Here 
62
  std::string m_release;
62
  std::string m_release;
63
  std::string m_version;
63
  std::string m_version;
64
  std::string m_hardId;
64
  std::string m_hardId;
65
  RandomVariable m_randomCtx;
65
  Ptr<RandomVariableStream> m_randomCtx;
66
  uint32_t m_rndBuffer;
66
  uint32_t m_rndBuffer;
67
  uint8_t m_rndOffset;
67
  uint8_t m_rndOffset;
68
};
68
};
(-)a/model/dce.cc (-3 / +2 lines)
 Lines 30-36    Link Here 
30
#include "ns3/log.h"
30
#include "ns3/log.h"
31
#include "ns3/simulator.h"
31
#include "ns3/simulator.h"
32
#include "ns3/names.h"
32
#include "ns3/names.h"
33
#include "ns3/random-variable.h"
34
#include "ns3/ipv4-l3-protocol.h"
33
#include "ns3/ipv4-l3-protocol.h"
35
#include "socket-fd-factory.h"
34
#include "socket-fd-factory.h"
36
35
 Lines 330-341    Link Here 
330
long int dce_random (void)
329
long int dce_random (void)
331
{
330
{
332
  Thread *current = Current ();
331
  Thread *current = Current ();
333
  return current->process->rndVarible.GetInteger ();
332
  return current->process->rndVariable->GetInteger ();
334
}
333
}
335
int dce_rand (void)
334
int dce_rand (void)
336
{
335
{
337
  Thread *current = Current ();
336
  Thread *current = Current ();
338
  return current->process->rndVarible.GetInteger ();
337
  return current->process->rndVariable->GetInteger ();
339
}
338
}
340
unsigned short int * dce_seed48 (unsigned short int seed16v[3])
339
unsigned short int * dce_seed48 (unsigned short int seed16v[3])
341
{
340
{
(-)a/model/kernel-socket-fd-factory.cc (-5 / +6 lines)
 Lines 78-86    Link Here 
78
                   MakeDoubleAccessor (&KernelSocketFdFactory::m_rate),
78
                   MakeDoubleAccessor (&KernelSocketFdFactory::m_rate),
79
                   MakeDoubleChecker<double> ())
79
                   MakeDoubleChecker<double> ())
80
    .AddAttribute ("RanVar", "The decision variable attached to this error model.",
80
    .AddAttribute ("RanVar", "The decision variable attached to this error model.",
81
                   RandomVariableValue (UniformVariable (0.0, 1.0)),
81
                   StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"),
82
                   MakeRandomVariableAccessor (&KernelSocketFdFactory::m_ranvar),
82
                   MakePointerAccessor (&KernelSocketFdFactory::m_ranvar),
83
                   MakeRandomVariableChecker ())
83
                   MakePointerChecker<RandomVariableStream> ())
84
  ;
84
  ;
85
  return tid;
85
  return tid;
86
}
86
}
 Lines 91-96    Link Here 
91
    m_logFile (0)
91
    m_logFile (0)
92
{
92
{
93
  TypeId::LookupByNameFailSafe ("ns3::LteUeNetDevice", &m_lteUeTid);
93
  TypeId::LookupByNameFailSafe ("ns3::LteUeNetDevice", &m_lteUeTid);
94
  m_variable = CreateObject<UniformRandomVariable> ();
94
}
95
}
95
96
96
KernelSocketFdFactory::~KernelSocketFdFactory ()
97
KernelSocketFdFactory::~KernelSocketFdFactory ()
 Lines 137-143    Link Here 
137
KernelSocketFdFactory::Malloc (struct SimKernel *kernel, unsigned long size)
138
KernelSocketFdFactory::Malloc (struct SimKernel *kernel, unsigned long size)
138
{
139
{
139
  KernelSocketFdFactory *self = (KernelSocketFdFactory *)kernel;
140
  KernelSocketFdFactory *self = (KernelSocketFdFactory *)kernel;
140
  if (self->m_ranvar.GetValue () < self->m_rate)
141
  if (self->m_ranvar->GetValue () < self->m_rate)
141
    {
142
    {
142
      NS_LOG_DEBUG ("return null");
143
      NS_LOG_DEBUG ("return null");
143
      // Inject fault
144
      // Inject fault
 Lines 256-262    Link Here 
256
  } u;
257
  } u;
257
  for (uint8_t i = 0; i < sizeof (u.buffer); i++)
258
  for (uint8_t i = 0; i < sizeof (u.buffer); i++)
258
    {
259
    {
259
      u.buffer[i] = self->m_variable.GetInteger (0,255);
260
      u.buffer[i] = self->m_variable->GetInteger (0,255);
260
    }
261
    }
261
  return u.v;
262
  return u.v;
262
}
263
}
(-)a/model/kernel-socket-fd-factory.h (-3 / +3 lines)
 Lines 4-10    Link Here 
4
#include "socket-fd-factory.h"
4
#include "socket-fd-factory.h"
5
#include "task-manager.h"
5
#include "task-manager.h"
6
#include "ns3/net-device.h"
6
#include "ns3/net-device.h"
7
#include "ns3/random-variable.h"
7
#include "ns3/random-variable-stream.h"
8
#include <sys/socket.h>
8
#include <sys/socket.h>
9
#include <vector>
9
#include <vector>
10
#include <string>
10
#include <string>
 Lines 142-152    Link Here 
142
142
143
  std::vector<std::pair<Ptr<NetDevice>,struct SimDevice *> > m_devices;
143
  std::vector<std::pair<Ptr<NetDevice>,struct SimDevice *> > m_devices;
144
  std::list<Task *> m_kernelTasks;
144
  std::list<Task *> m_kernelTasks;
145
  UniformVariable m_variable;
145
  Ptr<UniformRandomVariable> m_variable;
146
  KingsleyAlloc *m_alloc;
146
  KingsleyAlloc *m_alloc;
147
  std::vector<Ptr<KernelDeviceStateListener> > m_listeners;
147
  std::vector<Ptr<KernelDeviceStateListener> > m_listeners;
148
  double m_rate;
148
  double m_rate;
149
  RandomVariable m_ranvar;
149
  Ptr<RandomVariableStream> m_ranvar;
150
  uint16_t m_pid;
150
  uint16_t m_pid;
151
  TypeId m_lteUeTid;
151
  TypeId m_lteUeTid;
152
};
152
};
(-)a/model/process-delay-model.cc (-5 / +8 lines)
 Lines 19-24    Link Here 
19
 */
19
 */
20
#include "process-delay-model.h"
20
#include "process-delay-model.h"
21
#include "ns3/log.h"
21
#include "ns3/log.h"
22
#include "ns3/string.h"
23
#include "ns3/pointer.h"
22
#include <sys/time.h>
24
#include <sys/time.h>
23
#include <time.h>
25
#include <time.h>
24
26
 Lines 45-53    Link Here 
45
    .SetParent<ProcessDelayModel> ()
47
    .SetParent<ProcessDelayModel> ()
46
    .AddConstructor<RandomProcessDelayModel> ()
48
    .AddConstructor<RandomProcessDelayModel> ()
47
    .AddAttribute ("Variable", "Pick the process delay at random.",
49
    .AddAttribute ("Variable", "Pick the process delay at random.",
48
                   RandomVariableValue (ConstantVariable (0.0)),
50
                   StringValue ("ns3::ConstantRandomVariable[Constant=0.0]"),
49
                   MakeRandomVariableAccessor (&RandomProcessDelayModel::m_variable),
51
                   MakePointerAccessor (&RandomProcessDelayModel::m_variable),
50
                   MakeRandomVariableChecker ())
52
                   MakePointerChecker<RandomVariableStream> ())
51
  ;
53
  ;
52
  return tid;
54
  return tid;
53
}
55
}
 Lines 57-64    Link Here 
57
}
59
}
58
60
59
void
61
void
60
RandomProcessDelayModel::SetVariable (RandomVariable variable)
62
RandomProcessDelayModel::SetVariable (Ptr<RandomVariableStream> variable)
61
{
63
{
64
  m_variable = variable;
62
}
65
}
63
66
64
void
67
void
 Lines 68-74    Link Here 
68
Time
71
Time
69
RandomProcessDelayModel::RecordEnd (void)
72
RandomProcessDelayModel::RecordEnd (void)
70
{
73
{
71
  return Seconds (m_variable.GetValue ());
74
  return Seconds (m_variable->GetValue ());
72
}
75
}
73
76
74
NS_OBJECT_ENSURE_REGISTERED (TimeOfDayProcessDelayModel);
77
NS_OBJECT_ENSURE_REGISTERED (TimeOfDayProcessDelayModel);
(-)a/model/process-delay-model.h (-3 / +3 lines)
 Lines 21-27    Link Here 
21
#define PROCESS_DELAY_MODEL_H
21
#define PROCESS_DELAY_MODEL_H
22
22
23
#include "ns3/object.h"
23
#include "ns3/object.h"
24
#include "ns3/random-variable.h"
24
#include "ns3/random-variable-stream.h"
25
#include "ns3/nstime.h"
25
#include "ns3/nstime.h"
26
26
27
namespace ns3 {
27
namespace ns3 {
 Lines 42-54    Link Here 
42
42
43
  RandomProcessDelayModel ();
43
  RandomProcessDelayModel ();
44
44
45
  void SetVariable (RandomVariable variable);
45
  void SetVariable (Ptr<RandomVariableStream> variable);
46
46
47
  virtual void RecordStart (void);
47
  virtual void RecordStart (void);
48
  virtual Time RecordEnd (void);
48
  virtual Time RecordEnd (void);
49
49
50
private:
50
private:
51
  RandomVariable m_variable;
51
  Ptr<RandomVariableStream> m_variable;
52
};
52
};
53
53
54
class TimeOfDayProcessDelayModel : public ProcessDelayModel
54
class TimeOfDayProcessDelayModel : public ProcessDelayModel
(-)a/model/process.h (-2 / +2 lines)
 Lines 31-37    Link Here 
31
#include "ns3/event-id.h"
31
#include "ns3/event-id.h"
32
#include "ns3/nstime.h"
32
#include "ns3/nstime.h"
33
#include "unix-fd.h"
33
#include "unix-fd.h"
34
#include "ns3/random-variable.h"
34
#include "ns3/random-variable-stream.h"
35
35
36
class KingsleyAlloc;
36
class KingsleyAlloc;
37
37
 Lines 188-194    Link Here 
188
  // lifetime due to weirdness in the posix API.
188
  // lifetime due to weirdness in the posix API.
189
  std::vector<void *> allocated;
189
  std::vector<void *> allocated;
190
  //random variable for rand and random implementation
190
  //random variable for rand and random implementation
191
  RandomVariable rndVarible;
191
  Ptr<RandomVariableStream> rndVariable;
192
  // srand48 seed
192
  // srand48 seed
193
  struct drand48_data seed48Current;
193
  struct drand48_data seed48Current;
194
  // Current umask
194
  // Current umask
(-)a/myscripts/ccn-tap-vlc/dce-ccn-vlc.cc (-1 / +1 lines)
 Lines 154-160    Link Here 
154
  NetDeviceContainer devices = csma.Install (nodes);
154
  NetDeviceContainer devices = csma.Install (nodes);
155
155
156
  Ptr<RateErrorModel> em = CreateObjectWithAttributes<RateErrorModel> (
156
  Ptr<RateErrorModel> em = CreateObjectWithAttributes<RateErrorModel> (
157
      "RanVar", RandomVariableValue (UniformVariable (0., 1.)),
157
      "RanVar", StringValue("ns3::UniformRandomVariable[Min=0.|Max=1.]"),
158
      "ErrorRate", DoubleValue (0.00001));
158
      "ErrorRate", DoubleValue (0.00001));
159
  // devices.Get (0)->SetAttribute ("ReceiveErrorModel", PointerValue (em));
159
  // devices.Get (0)->SetAttribute ("ReceiveErrorModel", PointerValue (em));
160
160

Return to bug 2009