Attachment #3031 for bug #2726

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

(-)a/src/core/examples/hash-example.cc (-1 / +1 lines)

Lines 359-365	Link Here

359

//

359

//

360

    // Number of buckets = k = 2^bits

360

    // Number of buckets = k = 2^bits

361

    long double k32 = 0xFFFFFFFF;

361

    long double k32 = 0xFFFFFFFF;

362

    long double k64 = 0xFFFFFFFFFFFFFFFFULL;

362

    long double k64 = static_cast<long double> (0xFFFFFFFFFFFFFFFFULL);

363

364

    long double n = m_nphrases;

364

    long double n = m_nphrases;

365

    long double Ec32 = n * (n - 1) / ( 2 * k32) * (1 - (n - 2)/(3 * k32));

365

    long double Ec32 = n * (n - 1) / ( 2 * k32) * (1 - (n - 2)/(3 * k32));

(-)a/src/core/helper/random-variable-stream-helper.cc (-2 / +3 lines)

Lines 39-46	Link Here

  NS_LOG_FUNCTION_NOARGS ();

  NS_LOG_FUNCTION_NOARGS ();

  NS_ASSERT (stream >= 0);

  NS_ASSERT (stream >= 0);

  Config::MatchContainer mc = Config::LookupMatches (path);

  Config::MatchContainer mc = Config::LookupMatches (path);

  int64_t i = 0;

  for (Config::MatchContainer::Iterator mci = mc.Begin (); mci != mc.End (); ++mci, ++i)

  std::size_t i = 0;

  for ( ; i < mc.GetN (); ++i)

      PointerValue ptr = mc.Get (i);

      PointerValue ptr = mc.Get (i);

      Ptr<RandomVariableStream> rvs = ptr.Get<RandomVariableStream> ();

      Ptr<RandomVariableStream> rvs = ptr.Get<RandomVariableStream> ();

(-)a/src/core/model/attribute-accessor-helper.h (+5 lines)

Lines 21-26	Link Here

#define ATTRIBUTE_ACCESSOR_HELPER_H

#define ATTRIBUTE_ACCESSOR_HELPER_H

#include "attribute.h"

#include "attribute.h"

#include "unused.h"

/**

/**

 * \file

 * \file

Lines 325-330	Link Here

325

{}

326

{}

326

private:

327

private:

327

    virtual bool DoSet (T *object, const V *v) const {

328

    virtual bool DoSet (T *object, const V *v) const {

329

      NS_UNUSED (object);

330

      NS_UNUSED (v);

328

      return false;

331

      return false;

329

332

330

    virtual bool DoGet (const T *object, V *v) const {

333

    virtual bool DoGet (const T *object, V *v) const {

Lines 385-390	Link Here

385

      return true;

388

      return true;

386

389

387

    virtual bool DoGet (const T *object, V *v) const {

390

    virtual bool DoGet (const T *object, V *v) const {

391

      NS_UNUSED (object);

392

      NS_UNUSED (v);

388

      return false;

393

      return false;

389

394

390

    virtual bool HasGetter (void) const {

395

    virtual bool HasGetter (void) const {

(-)a/src/core/model/cairo-wideint.c (-7 / +9 lines)

Lines 27-32	Link Here

 * Contributor(s):

 * Contributor(s):

 *	Keith R. Packard <keithp@keithp.com>

 *	Keith R. Packard <keithp@keithp.com>

 * Code changes from for ns-3 from upstream are marked with `//PDB'

*/

*/

#include "cairo-wideint-private.h"

#include "cairo-wideint-private.h"

Lines 311-321	Link Here

311

	den = _cairo_int64_negate (den);

313

	den = _cairo_int64_negate (den);

312

    uqr = _cairo_uint64_divrem (num, den);

314

    uqr = _cairo_uint64_divrem (num, den);

313

    if (num_neg)

315

    if (num_neg)

314

	qr.rem = _cairo_int64_negate (uqr.rem);

316

        qr.rem = _cairo_int64_negate ((cairo_int64_t)uqr.rem);  //PDB

315

    else

317

    else

316

	qr.rem = uqr.rem;

318

	qr.rem = uqr.rem;

317

    if (num_neg != den_neg)

319

    if (num_neg != den_neg)

318

	qr.quo = (cairo_int64_t) _cairo_int64_negate (uqr.quo);

320

	qr.quo = (cairo_int64_t) _cairo_int64_negate ((cairo_int64_t)uqr.quo);

319

    else

321

    else

320

	qr.quo = (cairo_int64_t) uqr.quo;

322

	qr.quo = (cairo_int64_t) uqr.quo;

321

    return qr;

323

    return qr;

Lines 689-695	Link Here

689

    cairo_uint64_t x = _cairo_uint128_to_uint64 (_cairo_uint128_rsl(num, 32));

691

    cairo_uint64_t x = _cairo_uint128_to_uint64 (_cairo_uint128_rsl(num, 32));

690

692

691

    /* Initialise the result to indicate overflow. */

693

    /* Initialise the result to indicate overflow. */

692

    result.quo = _cairo_uint32s_to_uint64 (-1U, -1U);

694

    result.quo = _cairo_uint32s_to_uint64 (UINT_MAX, UINT_MAX);  //PDB

693

    result.rem = den;

695

    result.rem = den;

694

696

695

    /* Don't bother if the quotient is going to overflow. */

697

    /* Don't bother if the quotient is going to overflow. */

Lines 756-762	Link Here

756

	/* Add the main term's contribution to quotient.  Note B-v =

758

	/* Add the main term's contribution to quotient.  Note B-v =

757

	 * -v as an uint32 (unless v = 0) */

759

	 * -v as an uint32 (unless v = 0) */

758

	if (v)

760

	if (v)

759

	    quorem = _cairo_uint64_divrem (_cairo_uint32x32_64_mul (q, -v), den);

761

	    quorem = _cairo_uint64_divrem (_cairo_uint32x32_64_mul (q, -(int32_t)v), den);  //PDB

760

	else

762

	else

761

	    quorem = _cairo_uint64_divrem (_cairo_uint32s_to_uint64 (q, 0), den);

763

	    quorem = _cairo_uint64_divrem (_cairo_uint32s_to_uint64 (q, 0), den);

762

	quotient += _cairo_uint64_to_uint32 (quorem.quo);

764

	quotient += _cairo_uint64_to_uint32 (quorem.quo);

Lines 805-821	Link Here

805

    uqr = _cairo_uint_96by64_32x64_divrem (num, nonneg_den);

807

    uqr = _cairo_uint_96by64_32x64_divrem (num, nonneg_den);

806

    if (_cairo_uint64_eq (uqr.rem, _cairo_int64_to_uint64 (nonneg_den))) {

808

    if (_cairo_uint64_eq (uqr.rem, _cairo_int64_to_uint64 (nonneg_den))) {

807

	/* bail on overflow. */

809

	/* bail on overflow. */

808

	qr.quo = _cairo_uint32s_to_uint64 (0x7FFFFFFF, -1U);;

810

	qr.quo = _cairo_uint32s_to_uint64 (0x7FFFFFFF, UINT_MAX);  //PDB

809

	qr.rem = den;

811

	qr.rem = den;

810

	return qr;

812

	return qr;

811

813

812

814

813

    if (num_neg)

815

    if (num_neg)

814

	qr.rem = _cairo_int64_negate (uqr.rem);

816

	qr.rem = _cairo_int64_negate ((cairo_int64_t)uqr.rem);  //PDB

815

    else

817

    else

816

	qr.rem = uqr.rem;

818

	qr.rem = uqr.rem;

817

    if (num_neg != den_neg)

819

    if (num_neg != den_neg)

818

	qr.quo = _cairo_int64_negate (uqr.quo);

820

	qr.quo = _cairo_int64_negate ((cairo_int64_t)uqr.quo);  //PDB

819

    else

821

    else

820

	qr.quo = uqr.quo;

822

	qr.quo = uqr.quo;

821

    return qr;

823

    return qr;




  uint64_t bucketTop = m_bucketTop;
  Scheduler::Event minEvent;
  minEvent.impl = 0;
  minEvent.key.m_ts = UINT64_MAX;
  minEvent.key.m_uid = UINT32_MAX;
  minEvent.key.m_context = 0;
  do
    {

    }
}

uint64_t
CalendarScheduler::CalculateNewWidth (void)
{
  NS_LOG_FUNCTION (this);

  return totalSeparation;
}
void
CalendarScheduler::DoResize (uint32_t newSize, uint64_t newWidth)
{
  NS_LOG_FUNCTION (this << newSize << newWidth);


  NS_LOG_FUNCTION (this << newSize);

  // PrintInfo ();
  uint64_t newWidth = CalculateNewWidth ();
  DoResize (newSize, newWidth);
}


(-)a/src/core/model/calendar-scheduler.h (-2 / +2 lines)

   * \returns The new width.

   * \returns The new width.

*/

*/

  uint32_t CalculateNewWidth (void);

  uint64_t CalculateNewWidth (void);

/**

/**

   * Initialize the calendar queue.

   * Initialize the calendar queue.

116

   * \param [in] newSize The number of buckets.

116

   * \param [in] newSize The number of buckets.

117

   * \param [in] newWidth The size of the new buckets.

117

   * \param [in] newWidth The size of the new buckets.

118

*/

118

*/

119

  void DoResize (uint32_t newSize, uint32_t newWidth);

119

  void DoResize (uint32_t newSize, uint64_t newWidth);

120

/**

120

/**

121

   * Remove the earliest event.

121

   * Remove the earliest event.

122




  NS_LOG_FUNCTION (this);
  return m_objects.end ();
}
std::size_t
MatchContainer::GetN (void) const
{
  NS_LOG_FUNCTION (this);
  return m_objects.size ();
}
Ptr<Object>
MatchContainer::Get (std::size_t i) const
{
  NS_LOG_FUNCTION (this << i);
  return m_objects[i];

                  continue;
                }
              // attempt to cast to a pointer checker.
              const PointerChecker *pChecker = dynamic_cast<const PointerChecker *> (PeekPointer (info.checker));
              if (pChecker != 0)
                {
                  NS_LOG_DEBUG ("GetAttribute(ptr)="<<info.name<<" on path="<<GetResolvedPath ());
                  PointerValue pValue;
                  root->GetAttribute (info.name, pValue);
                  Ptr<Object> object = pValue.Get<Object> ();
                  if (object == 0)
                    {
                      NS_LOG_ERROR ("Requested object name=\""<<item<<

  void UnregisterRootNamespaceObject (Ptr<Object> obj);

  /** \copydoc Config::GetRootNamespaceObjectN() */
  std::size_t GetRootNamespaceObjectN (void) const;
  /** \copydoc Config::GetRootNamespaceObject() */
  Ptr<Object> GetRootNamespaceObject (std::size_t i) const;

private:
  /**

    }
}

std::size_t 
ConfigImpl::GetRootNamespaceObjectN (void) const
{
  NS_LOG_FUNCTION (this);
  return m_roots.size ();
}
Ptr<Object> 
ConfigImpl::GetRootNamespaceObject (std::size_t i) const
{
  NS_LOG_FUNCTION (this << i);
  return m_roots[i];




  /**
   * \returns The number of items in the container
   */
  std::size_t GetN (void) const;
  /**
   * \param [in] i Index of item to lookup ([0,n[)
   * \returns The item requested.
   */
  Ptr<Object> Get (std::size_t i) const;
  /**
   * \param [in] i Index of item to lookup ([0,n[)
   * \returns The fully-qualified matching path associated

(-)a/src/core/model/hash-fnv.cc (-2 / +2 lines)

Lines 159-165	Link Here

159

/**

159

/**

160

 * 32 bit FNV-0 hash type

160

 * 32 bit FNV-0 hash type

161

*/

161

*/

162

typedef u_int32_t Fnv32_t;

162

typedef uint32_t Fnv32_t;  //PDB

163

164

165

/**

165

/**

Lines 202-208	Link Here

202

 * 64 bit FNV-0 hash

202

 * 64 bit FNV-0 hash

203

*/

203

*/

204

#if defined(HAVE_64BIT_LONG_LONG)

204

#if defined(HAVE_64BIT_LONG_LONG)

205

typedef u_int64_t Fnv64_t;

205

typedef uint64_t Fnv64_t;  //PDB

206

#else /* HAVE_64BIT_LONG_LONG */

206

#else /* HAVE_64BIT_LONG_LONG */

207

typedef struct {

207

typedef struct {

208

    u_int32_t w32[2]; /* w32[0] is low order, w32[1] is high order word */

208

    u_int32_t w32[2]; /* w32[0] is low order, w32[1] is high order word */




  h1 += h2;
  h2 += h1;

  ((uint32_t *)out)[0] = static_cast<uint32_t> (h1);  //PDB
  ((uint32_t *)out)[1] = static_cast<uint32_t> (h2);  //PDB
}



{
  using namespace Murmur3Implementation;

  MurmurHash3_x86_32_incr (buffer, static_cast<int> (size),
                           m_hash32, (void *) & m_hash32);
  m_size32 += size;
  uint32_t hash;
  MurmurHash3_x86_32_fin  (m_size32, m_hash32, (void *) & hash);

Murmur3::GetHash64  (const char * buffer, const size_t size)
{
  using namespace Murmur3Implementation;

  MurmurHash3_x86_128_incr (buffer, static_cast<int> (size),
                            (uint32_t *)(void *)m_hash64, m_hash64);
  m_size64 += size;


  // Using uint32_t here avoids the bug, and continues to works with newer gcc.
  uint32_t hash[4];
  
  MurmurHash3_x86_128_fin (static_cast<int> (m_size64),
                           (uint32_t *)(void *)m_hash64, hash);
  uint64_t result = hash[1];
  result = (result << 32) | hash[0];

{
  m_hash32 = (uint32_t)SEED;
  m_size32 = 0;
  m_hash64[0] = m_hash64[1] = ((uint64_t)SEED << 32) | (uint32_t)SEED;
  m_size64 = 0;
}


(-)a/src/core/model/hash-murmur3.h (-1 / +1 lines)

Lines 109-115	Link Here

109

*/

109

*/

110

  /**@{*/

110

  /**@{*/

111

  uint32_t m_hash32;

111

  uint32_t m_hash32;

112

  uint32_t m_size32;

112

  uint64_t m_size32;

113

  /**@}*/

113

  /**@}*/

114

115

  /** murmur3 produces 128-bit hash and state; we use just the first 64-bits. */

115

  /** murmur3 produces 128-bit hash and state; we use just the first 64-bits. */

(-)a/src/core/model/heap-scheduler.cc (-1 / +1 lines)

Lines 102-108	Link Here

102

  return (id == Root ()) ? true : false;

102

  return (id == Root ()) ? true : false;

103

104

105

uint32_t

105

std::size_t

106

HeapScheduler::Last (void) const

106

HeapScheduler::Last (void) const

107

108

  NS_LOG_FUNCTION (this);

108

  NS_LOG_FUNCTION (this);

(-)a/src/core/model/heap-scheduler.h (-1 / +1 lines)

Lines 113-119	Link Here

113

   * Return the index of the last element.

113

   * Return the index of the last element.

114

   * \returns The last index.

114

   * \returns The last index.

115

*/

115

*/

116

  uint32_t Last (void) const;

116

  std::size_t Last (void) const;

117

/**

117

/**

118

   * Test if an index is the root.

118

   * Test if an index is the root.

119

(-)a/src/core/model/int64x64-cairo.cc (-2 / +2 lines)

Lines 174-180	Link Here

174

      qr = _cairo_uint128_divrem (rem, den);

174

      qr = _cairo_uint128_divrem (rem, den);

175

176

      // Add in the quotient as shift bits of the fraction

176

      // Add in the quotient as shift bits of the fraction

177

      result = _cairo_uint128_lsl (result, shift);

177

      result = _cairo_uint128_lsl (result, static_cast<int> (shift));

178

      result = _cairo_uint128_add (result, qr.quo);

178

      result = _cairo_uint128_add (result, qr.quo);

179

      rem = qr.rem;

179

      rem = qr.rem;

180

      digis += shift;

180

      digis += shift;

Lines 184-190	Link Here

184

  if (digis < DIGITS)

184

  if (digis < DIGITS)

185

186

      shift = DIGITS - digis;

186

      shift = DIGITS - digis;

187

      result = _cairo_uint128_lsl (result, shift);

187

      result = _cairo_uint128_lsl (result, static_cast<int> (shift));

188

189

190

  return result;

190

  return result;




    //   TestSuite int64x64
    const long double round = 0.5;
    flo = flo * HP_MAX_64 + round;
    cairo_int64_t  hi = (cairo_int64_t)fhi;
    const cairo_uint64_t lo = (cairo_uint64_t)flo;
    if (flo >= HP_MAX_64)
      {
	// conversion to uint64 rolled over

  {
    const bool negative = _cairo_int128_negative (_v);
    const cairo_int128_t value = negative ? _cairo_int128_negate (_v) : _v;
    const long double fhi = static_cast<long double> (value.hi);
    const long double flo = value.lo / HP_MAX_64;
    long double retval = fhi;
    retval += flo;
    retval = negative ? -retval : retval;
    return static_cast<double> (retval);
  }
  /**
   * Get the integer portion.




  inline int64x64_t (long int v)
    : _v (v) {}
  inline int64x64_t (long long int v)
    : _v (static_cast<double> (v)) {}
  inline int64x64_t (unsigned int v)
    : _v (v) {}
  inline int64x64_t (unsigned long int v)
    : _v (v) {}
  inline int64x64_t (unsigned long long int v)
    : _v (static_cast<double> (v)) {}
  /**@}*/
  /**
   * Construct from explicit high and low values.

  explicit inline int64x64_t (int64_t hi, uint64_t lo)
  {
    const bool negative = hi < 0;
    const long double hild = static_cast<long double> (hi);
    const long double fhi = negative ? -hild : hild;
    const long double flo = lo / HP_MAX_64;
    _v = negative ? - fhi : fhi;
    _v += flo;

    //   TestSuite int64x64
    const long double round = 0.5;
    flo = flo * HP_MAX_64 + round;
    int64_t  hi = static_cast<int64_t> (fhi);
    uint64_t lo = static_cast<uint64_t> (flo);
    if (flo >= HP_MAX_64)
      {
	// conversion to uint64 rolled over




  return *this;
}

template<>
ParameterLogger&
ParameterLogger::operator<< <int8_t>(const int8_t param)
{
  if (m_first)
  {
    m_os << static_cast<int16_t> (param);
    m_first = false;
  }
  else
  {
    m_os << static_cast<int16_t> (param);
  }
  return *this;
}

template<>
ParameterLogger&
ParameterLogger::operator<< <uint8_t>(const uint8_t param)
{
  if (m_first)
  {
    m_os << static_cast<uint16_t> (param);
    m_first = false;
  }
  else
  {
    m_os << static_cast<uint16_t> (param);
  }
  return *this;
}

} // namespace ns3




ParameterLogger&
ParameterLogger::operator<< <const char *>(const char * param);
  
/**
 * Specialization for int8_t.
 * \param [in] param The function parameter.
 * \return This ParameterLogger, so it's chainable.
 */
template<>
ParameterLogger&
  ParameterLogger::operator<< <int8_t>(int8_t param);

/**
 * Specialization for uint8_t.
 * \param [in] param The function parameter.
 * \return This ParameterLogger, so it's chainable.
 */
template<>
ParameterLogger&
  ParameterLogger::operator<< <uint8_t>(uint8_t param);

} // namespace ns3

/**@}*/  // \ingroup logging

(-)a/src/core/model/nstime.h (-1 / +1 lines)

Lines 380-386	Link Here

380

381

  inline double GetDouble (void) const

381

  inline double GetDouble (void) const

382

383

    return m_data;

383

    return static_cast<double> (m_data);

384

385

  inline int64_t GetInteger (void) const

385

  inline int64_t GetInteger (void) const

386

(-)a/src/core/model/object-base.cc (-2 / +2 lines)

Lines 140-149	Link Here

140

                  if (equal != std::string::npos)

140

                  if (equal != std::string::npos)

141

142

                      std::string name = tmp.substr (0, equal);

142

                      std::string name = tmp.substr (0, equal);

143

                      std::string value = tmp.substr (equal+1, tmp.size () - equal - 1);

143

                      std::string envval = tmp.substr (equal+1, tmp.size () - equal - 1);

144

                      if (name == tid.GetAttributeFullName (i))

144

                      if (name == tid.GetAttributeFullName (i))

145

146

                          if (DoSet (info.accessor, info.checker, StringValue (value)))

146

                          if (DoSet (info.accessor, info.checker, StringValue (envval)))

147

148

                              NS_LOG_DEBUG ("construct \""<< tid.GetName ()<<"::"<<

148

                              NS_LOG_DEBUG ("construct \""<< tid.GetName ()<<"::"<<

149

                                            info.name <<"\" from env var");

149

                                            info.name <<"\" from env var");

(-)a/src/core/model/object-map.h (-2 / +2 lines)

Lines 81-87	Link Here

  struct MemberStdContainer : public ObjectPtrContainerAccessor

  struct MemberStdContainer : public ObjectPtrContainerAccessor

    virtual bool DoGetN (const ObjectBase *object, uint32_t *n) const {

    virtual bool DoGetN (const ObjectBase *object, std::size_t *n) const {

      const T *obj = dynamic_cast<const T *> (object);

      const T *obj = dynamic_cast<const T *> (object);

      if (obj == 0)

      if (obj == 0)

Lines 90-96	Link Here

      *n = (obj->*m_memberVector).size ();

      *n = (obj->*m_memberVector).size ();

      return true;

      return true;

    virtual Ptr<Object> DoGet (const ObjectBase *object, uint32_t i, uint32_t *index) const {

    virtual Ptr<Object> DoGet (const ObjectBase *object, std::size_t i, std::size_t *index) const {

      const T *obj = static_cast<const T *> (object);

      const T *obj = static_cast<const T *> (object);

      typename U::const_iterator begin = (obj->*m_memberVector).begin ();

      typename U::const_iterator begin = (obj->*m_memberVector).begin ();

      typename U::const_iterator end = (obj->*m_memberVector).end ();

      typename U::const_iterator end = (obj->*m_memberVector).end ();




  NS_LOG_FUNCTION (this);
  return m_objects.end ();
}
std::size_t
ObjectPtrContainerValue::GetN (void) const
{
  NS_LOG_FUNCTION (this);
  return m_objects.size ();
}
Ptr<Object>
ObjectPtrContainerValue::Get (std::size_t i) const
{
  NS_LOG_FUNCTION (this << i);
  Iterator it = m_objects.find (i); 

      return false;
    }
  v->m_objects.clear ();
  std::size_t n;
  bool ok = DoGetN (object, &n);
  if (!ok)
    {

    }
  for (uint32_t i = 0; i < n; i++)
    {
      std::size_t index;
      Ptr<Object> o = DoGet (object, i, &index);
      v->m_objects.insert (std::pair <uint32_t, Ptr<Object> > (index, o));
    }




   *
   * \returns The number of objects.
   */
  std::size_t GetN (void) const;
  /**
   * Get a specific Object.
   *
   * \param [in] i The index of the requested object.
   * \returns The requested object
   */
  Ptr<Object> Get (std::size_t i) const;

  /**
   * Get a copy of this container.

   * \param [out] n The number of instances in the container.
   * \returns true if the value could be obtained successfully.
   */
  virtual bool DoGetN (const ObjectBase *object, std::size_t *n) const = 0;
  /**
   * Get an instance from the container, identified by index.
   *

   * \param [out] index The index retrieved.
   * \returns The index requested.
   */
  virtual Ptr<Object> DoGet (const ObjectBase *object, std::size_t i, std::size_t *index) const = 0;
};

template <typename T, typename U, typename INDEX>

{
  struct MemberGetters : public ObjectPtrContainerAccessor
  {
    virtual bool DoGetN (const ObjectBase *object, std::size_t *n) const {
      const T *obj = dynamic_cast<const T *> (object);
      if (obj == 0)
        {
          return false;
        }
      *n = static_cast<std::size_t> ((obj->*m_getN)());
      return true;
    }
    virtual Ptr<Object> DoGet (const ObjectBase *object, std::size_t i, std::size_t *index) const {
      const T *obj = static_cast<const T *> (object);
      *index = i;
      return (obj->*m_get)(i);




{
  struct MemberStdContainer : public ObjectPtrContainerAccessor
  {
    virtual bool DoGetN (const ObjectBase *object, std::size_t *n) const {
      const T *obj = dynamic_cast<const T *> (object);
      if (obj == 0)
        {

      *n = (obj->*m_memberVector).size ();
      return true;
    }
    virtual Ptr<Object> DoGet (const ObjectBase *object, std::size_t i, std::size_t *index) const {
      const T *obj = static_cast<const T *> (object);
      typename U::const_iterator begin = (obj->*m_memberVector).begin ();
      typename U::const_iterator end = (obj->*m_memberVector).end ();
      std::size_t k = 0;
      for (typename U::const_iterator j = begin; j != end; j++, k++)
        {
          if (k == i)

(-)a/src/core/model/random-variable-stream.cc (-2 / +2 lines)

Lines 1488-1494	Link Here

1488

1489

1490

void

1490

void

1491

DeterministicRandomVariable::SetValueArray (double* values, uint64_t length)

1491

DeterministicRandomVariable::SetValueArray (double* values, std::size_t length)

1492

1493

  NS_LOG_FUNCTION (this << values << length);

1493

  NS_LOG_FUNCTION (this << values << length);

1494

  // Delete any values currently set.

1494

  // Delete any values currently set.

Lines 1503-1509	Link Here

1503

  m_next = length;

1503

  m_next = length;

1504

1505

  // Copy the values.

1505

  // Copy the values.

1506

  for (uint64_t i = 0; i < m_count; i++)

1506

  for (std::size_t i = 0; i < m_count; i++)

1507

1508

      m_data[i] = values[i];

1508

      m_data[i] = values[i];

1509




   * Note that the values in the array are copied and stored
   * (deep-copy).
   */
  void SetValueArray (double* values, std::size_t length);

  /**
   * \brief Returns the next value in the sequence.

  virtual uint32_t GetInteger (void);

private:
  /** Size of the array of values. */
  std::size_t   m_count;

  /** Position of the next value in the array of values. */
  std::size_t   m_next;

  /** Array of values to return in sequence. */
  double* m_data;

(-)a/src/core/model/realtime-simulator-impl.cc (-2 / +2 lines)

Lines 373-379	Link Here

373

            tsJitter = m_currentTs - tsFinal;

373

            tsJitter = m_currentTs - tsFinal;

374

375

376

        if (tsJitter > static_cast<uint64_t>(m_hardLimit.GetTimeStep ()))

376

        if (tsJitter > static_cast<uint64_t> (m_hardLimit.GetTimeStep ()))

377

378

            NS_FATAL_ERROR ("RealtimeSimulatorImpl::ProcessOneEvent (): "

378

            NS_FATAL_ERROR ("RealtimeSimulatorImpl::ProcessOneEvent (): "

379

                            "Hard real-time limit exceeded (jitter = " << tsJitter << ")");

379

                            "Hard real-time limit exceeded (jitter = " << tsJitter << ")");

Lines 433-439	Link Here

433

  m_synchronizer->SetOrigin (m_currentTs);

433

  m_synchronizer->SetOrigin (m_currentTs);

434

435

  // Sleep until signalled

435

  // Sleep until signalled

436

  uint64_t tsNow;

436

  uint64_t tsNow = 0;

437

  uint64_t tsDelay = 1000000000; // wait time of 1 second (in nanoseconds)

437

  uint64_t tsDelay = 1000000000; // wait time of 1 second (in nanoseconds)

438

439

  while (!m_stop)

439

  while (!m_stop)




#include "rng-seed-manager.h"
#include "global-value.h"
#include "attribute-helper.h"
#include "uinteger.h"
#include "config.h"
#include "log.h"


 */
static ns3::GlobalValue g_rngSeed ("RngSeed", 
                                   "The global seed of all rng streams",
                                   ns3::UintegerValue(1),
                                   ns3::MakeUintegerChecker<uint32_t> ());
/**
 * \relates RngSeedManager
 * The random number generator substream index.  This is used to generate

 */
static ns3::GlobalValue g_rngRun ("RngRun", 
                                  "The substream index used for all streams",
                                  ns3::UintegerValue (1),
                                  ns3::MakeUintegerChecker<uint64_t> ());


uint32_t RngSeedManager::GetSeed (void)
{
  NS_LOG_FUNCTION_NOARGS ();
  UintegerValue seedValue;
  g_rngSeed.GetValue (seedValue);
  return static_cast<uint32_t> (seedValue.Get ());
}
void 
RngSeedManager::SetSeed (uint32_t seed)
{
  NS_LOG_FUNCTION (seed);
  Config::SetGlobal ("RngSeed", UintegerValue(seed));
}

void RngSeedManager::SetRun (uint64_t run)
{
  NS_LOG_FUNCTION (run);
  Config::SetGlobal ("RngRun", UintegerValue (run));
}

uint64_t RngSeedManager::GetRun ()
{
  NS_LOG_FUNCTION_NOARGS ();
  UintegerValue value;
  g_rngRun.GetValue (value);
  uint64_t run = value.Get();
  return run;
}


(-)a/src/core/model/simple-ref-count.h (-1 / +5 lines)

Lines 25-30	Link Here

#include "empty.h"

#include "empty.h"

#include "default-deleter.h"

#include "default-deleter.h"

#include "assert.h"

#include "assert.h"

#include "unused.h"

#include <stdint.h>

#include <stdint.h>

#include <limits>

#include <limits>

Lines 82-88	Link Here

*/

*/

  SimpleRefCount (const SimpleRefCount &o)

  SimpleRefCount (const SimpleRefCount &o)

    : m_count (1)

    : m_count (1)

{}

    NS_UNUSED (o);

/**

/**

   * Assignment operator

   * Assignment operator

   * \param [in] o The object to copy

   * \param [in] o The object to copy

Lines 90-95	Link Here

*/

*/

  SimpleRefCount &operator = (const SimpleRefCount &o)

  SimpleRefCount &operator = (const SimpleRefCount &o)

    NS_UNUSED (o);

    return *this;

    return *this;

/**

/**

(-)a/src/core/model/simulator.h (-2 / +8 lines)

Lines 184-191	Link Here

184

*/

184

*/

185

  static uint32_t GetContext (void);

185

  static uint32_t GetContext (void);

186

187

  /** Context enum values. */

187

/**

188

  enum {

188

   * Context enum values.

189

190

   * \internal

191

   * This enum type is fixed to match the representation size

192

   * of simulation context.

193

*/

194

  enum : uint32_t {

189

/**

195

/**

190

     * Flag for events not associated with any particular context.

196

     * Flag for events not associated with any particular context.

191

*/

197

*/

(-)a/src/core/model/synchronizer.cc (-2 / +2 lines)

Lines 90-98	Link Here

  if (tDrift < 0)

  if (tDrift < 0)

      return -NanosecondToTimeStep (-tDrift);

      return -static_cast<int64_t> (NanosecondToTimeStep (-tDrift));

    } else {

    } else {

      return NanosecondToTimeStep (tDrift);

      return static_cast<int64_t> (NanosecondToTimeStep (tDrift));




#include <cstring>


#if defined (HAVE_DIRENT_H) && defined (HAVE_SYS_TYPES_H)
/** Do we have an \c opendir function? */
#define HAVE_OPENDIR
#include <sys/types.h>
#include <dirent.h>
#endif
#if defined (HAVE_SYS_STAT_H) && defined (HAVE_SYS_TYPES_H)
/** Do we have a \c makedir function? */
#define HAVE_MKDIR_H
#include <sys/types.h>




   * 
   * \returns The new test vector index
   */
  std::size_t Add (T vector);

  /**
   * \brief Get the total number of test vectors.
   * \return The number of test vectors
   */
  std::size_t GetN (void) const;
  /**
   * \brief Get the i'th test vector
   * \param [in] i The requested vector index
   * \return The requested vector
   */
  T Get (std::size_t i) const;

private:
  typedef std::vector<T> TestVector;    //!< Container type

}

template <typename T>
std::size_t
TestVectors<T>::Add (T vector)
{
  std::size_t index = m_vectors.size ();
  m_vectors.push_back (vector);
  return index;
}

template <typename T>
std::size_t 
TestVectors<T>::GetN (void) const
{
  return m_vectors.size ();


template <typename T>
T
TestVectors<T>::Get (std::size_t i) const
{
  NS_ABORT_MSG_UNLESS (m_vectors.size () > i, "TestVectors::Get(): Bad index");
  return m_vectors[i];




   * Add a constructor Callback to this type id.
   * \param [in] uid The id.
   * \param [in] callback The Callback for the constructor.
   * \param [in] canBeDupicate If true, this class can be registered more than once
   */
  void AddConstructor (uint16_t uid, Callback<ObjectBase *> callback, bool canBeDuplicate = false);
  /**
   * Mark this type id to be excluded from documentation.
   * \param [in] uid The id.

   * Get the total number of type ids.
   * \returns The total number.
   */
  uint16_t GetRegisteredN (void) const;
  /**
   * Get a type id by index.
   *

   * \param [in] i The index.
   * \returns The type id.
   */
  uint16_t GetRegistered (uint16_t i) const;
  /**
   * Record a new attribute in a type id.
   * \param [in] uid The id.

   * \param [in] initialValue The new initial value to use for this attribute.
   */
  void SetAttributeInitialValue(uint16_t uid,
                                std::size_t i,
                                Ptr<const AttributeValue> initialValue);
  /**
   * Get the number of attributes.
   * \param [in] uid The id.
   * \returns The number of attributes associated to this TypeId
   */
  std::size_t GetAttributeN (uint16_t uid) const;
  /**
   * Get Attribute information by index.
   * \param [in] uid The id.
   * \param [in] i Index into attribute array
   * \returns The information associated to attribute whose index is \p i.
   */
  struct TypeId::AttributeInformation GetAttribute(uint16_t uid, std::size_t i) const;
  /**
   * Record a new TraceSource.
   * \param [in] uid The id.

   *             "ns3::" namespace qualifier.  
   * \param [in] supportLevel The support/deprecation status for this attribute.
   * \param [in] supportMsg Upgrade hint if this attribute is no longer supported.
   * \param [in] canBeDupicate If true, this class can be registered more than once
   * \returns This TypeId instance.
   */
  void AddTraceSource (uint16_t uid,

                       Ptr<const TraceSourceAccessor> accessor,
                       std::string callback,
                       TypeId::SupportLevel supportLevel = TypeId::SUPPORTED,
                       const std::string &supportMsg = "",
                       bool canBeDuplicate = false);
  /**
   * Get the number of Trace sources.
   * \param [in] uid The id.
   * \returns The number of trace sources defined in this TypeId.
   */
  std::size_t GetTraceSourceN (uint16_t uid) const;
  /**
   * Get the trace source by index.
   * \param [in] uid The id.
   * \param [in] i Index into trace source array.
   * \returns Detailed information about the requested trace source.
   */
  struct TypeId::TraceSourceInformation GetTraceSource(uint16_t uid, std::size_t i) const;
  /**
   * Check if this TypeId should not be listed in documentation.
   * \param [in] uid The id.

    else
      { // chain old type
        NS_LOG_LOGIC (IIDL << "Old TypeId '" << hinfo->name << "' getting chained.");
        uint16_t oldUid = GetUid (hinfo->hash);
        m_hashmap.erase (m_hashmap.find (hinfo->hash));
        hinfo->hash = hash | HashChainFlag;
        m_hashmap.insert (std::make_pair (hinfo->hash, oldUid));

  information.hasConstructor = false;
  information.mustHideFromDocumentation = false;
  m_information.push_back (information);
  uint16_t uid = static_cast<uint16_t> (m_information.size ());
  NS_ASSERT (uid <= 0xffff);

  // Add to both maps:

}

void 
IidManager::AddConstructor (uint16_t uid, Callback<ObjectBase *> callback, bool canBeDuplicate)
{
  NS_LOG_FUNCTION (IID << uid << &callback);
  struct IidInformation *information = LookupInformation (uid);
  if (!canBeDuplicate && information->hasConstructor)
    {
      NS_FATAL_ERROR (information->name<<" already has a constructor.");
    }

  return hasC;
}

uint16_t
IidManager::GetRegisteredN (void) const
{
  NS_LOG_FUNCTION (IID << m_information.size ());
  return static_cast<uint16_t> (m_information.size ());
}
uint16_t 
IidManager::GetRegistered (uint16_t i) const
{
  NS_LOG_FUNCTION (IID << i);
  return i + 1;

}
void 
IidManager::SetAttributeInitialValue(uint16_t uid,
                                     std::size_t i,
                                     Ptr<const AttributeValue> initialValue)
{
  NS_LOG_FUNCTION (IID << uid << i << initialValue);




std::size_t 
IidManager::GetAttributeN (uint16_t uid) const
{
  NS_LOG_FUNCTION (IID << uid);
  struct IidInformation *information = LookupInformation (uid);
  std::size_t size = information->attributes.size ();
  NS_LOG_LOGIC (IIDL << size);
  return size;
}
struct TypeId::AttributeInformation 
IidManager::GetAttribute(uint16_t uid, std::size_t i) const
{
  NS_LOG_FUNCTION (IID << uid << i);
  struct IidInformation *information = LookupInformation (uid);

                            Ptr<const TraceSourceAccessor> accessor,
                            std::string callback,
                            TypeId::SupportLevel supportLevel,
                            const std::string &supportMsg,
                            bool canBeDuplicate)
{
  NS_LOG_FUNCTION (IID << uid << name << help
                   << accessor << callback
                   << supportLevel << supportMsg);
  struct IidInformation *information  = LookupInformation (uid);
  if (!canBeDuplicate && HasTraceSource(uid, name))
    {
      NS_FATAL_ERROR ("Trace source \"" << name << "\" already registered on tid=\"" << 
                      information->name << "\"");

  information->traceSources.push_back (source);
  NS_LOG_LOGIC (IIDL << information->traceSources.size () - 1);
}
std::size_t 
IidManager::GetTraceSourceN (uint16_t uid) const
{
  NS_LOG_FUNCTION (IID << uid);
  struct IidInformation *information = LookupInformation (uid);
  std::size_t size = information->traceSources.size ();
  NS_LOG_LOGIC (IIDL << size);
  return size;
}
struct TypeId::TraceSourceInformation 
IidManager::GetTraceSource(uint16_t uid, std::size_t i) const
{
  NS_LOG_FUNCTION (IID << uid << i);
  struct IidInformation *information = LookupInformation (uid);

 *         The TypeId class
 *********************************************************************/

TypeId::TypeId (const char *name, bool canBeDuplicate)
{
  NS_LOG_FUNCTION (this << name);
  uint16_t uid = 0;
  if (canBeDuplicate)
  {
    uid = IidManager::Get()->GetUid(name);
    NS_LOG_LOGIC(uid);
    if (uid != 0)
    {
      m_tid = uid;
      return;
    }
  }

  uid = IidManager::Get()->AllocateUid(name);
  NS_LOG_LOGIC(uid);
  NS_ASSERT(uid != 0);
  m_tid = uid;
}


TypeId::TypeId (uint16_t tid)
  : m_tid (tid)
{
  NS_LOG_FUNCTION (this << tid);
}

TypeId
TypeId::LookupByName (std::string name)
{

  return true;
}

uint16_t 
TypeId::GetRegisteredN (void)
{
  NS_LOG_FUNCTION_NOARGS ();
  return IidManager::Get ()->GetRegisteredN ();
}
TypeId 
TypeId::GetRegistered (uint16_t i)
{
  NS_LOG_FUNCTION (i);
  return TypeId (IidManager::Get ()->GetRegistered (i));

  TypeId nextTid = *this;
  do {
      tid = nextTid;
      for (std::size_t i = 0; i < tid.GetAttributeN (); i++)
        {
          struct TypeId::AttributeInformation tmp = tid.GetAttribute(i);
          if (tmp.name == name)

}

void
TypeId::DoAddConstructor (Callback<ObjectBase *> cb, bool canBeDuplicate)
{
  NS_LOG_FUNCTION (this << &cb);
  IidManager::Get ()->AddConstructor (m_tid, cb, canBeDuplicate);
}

TypeId 

}

bool 
TypeId::SetAttributeInitialValue(std::size_t i, 
                                 Ptr<const AttributeValue> initialValue)
{
  NS_LOG_FUNCTION (this << i << initialValue);

  return mustHide;
}

std::size_t
TypeId::GetAttributeN (void) const
{
  NS_LOG_FUNCTION (this);
  std::size_t n = IidManager::Get ()->GetAttributeN (m_tid);
  return n;
}
struct TypeId::AttributeInformation 
TypeId::GetAttribute(std::size_t i) const
{
  NS_LOG_FUNCTION (this << i);
  return IidManager::Get ()->GetAttribute(m_tid, i);
}
std::string 
TypeId::GetAttributeFullName (std::size_t i) const
{
  NS_LOG_FUNCTION (this << i);
  struct TypeId::AttributeInformation info = GetAttribute(i);
  return GetName () + "::" + info.name;
}

std::size_t 
TypeId::GetTraceSourceN (void) const
{
  NS_LOG_FUNCTION (this);
  return IidManager::Get ()->GetTraceSourceN (m_tid);
}
struct TypeId::TraceSourceInformation 
TypeId::GetTraceSource(std::size_t i) const
{
  NS_LOG_FUNCTION (this << i);
  return IidManager::Get ()->GetTraceSource(m_tid, i);

                        Ptr<const TraceSourceAccessor> accessor,
                        std::string callback,
                        SupportLevel supportLevel,
                        const std::string &supportMsg,
                        bool canBeDuplicate)
{
  NS_LOG_FUNCTION (this << name << help
                   << accessor << callback
                   << supportLevel << supportMsg);
  IidManager::Get ()->AddTraceSource (m_tid, name, help,
                                      accessor, callback,
                                      supportLevel, supportMsg,
                                      canBeDuplicate);
  return *this;
}


  struct TypeId::TraceSourceInformation tmp;
  do {
      tid = nextTid;
      for (std::size_t i = 0; i < tid.GetTraceSourceN (); i++)
        {
          tmp = tid.GetTraceSource (i);
          if (tmp.name == name)




   *
   * \returns The number of TypeId instances registered.
   */
  static uint16_t GetRegisteredN (void);
  /**
   * Get a TypeId by index.
   *
   * \param [in] i Index of the TypeId.
   * \returns The TypeId instance whose index is \c i.
   */
  static TypeId GetRegistered (uint16_t i);

  /**
   * Constructor.
   *
   * \param [in] name The name of the interface to construct.
   * \param [in] canBeDupicate If true, this class can be registered more than once
   *
   * No two instances can share the same name. The name is expected to be
   * the full c++ typename of associated c++ object.
   */
  explicit TypeId (const char * name, bool canBeDuplicate = false);

  /**
   * Get the parent of this TypeId.

   *
   * \returns The number of attributes associated to this TypeId
   */
  std::size_t GetAttributeN (void) const;
  /**
   * Get Attribute information by index.
   *
   * \param [in] i Index into attribute array
   * \returns The information associated to attribute whose index is \p i.
   */
  struct TypeId::AttributeInformation GetAttribute(std::size_t i) const;
  /**
   * Get the Attribute name by index.
   *
   * \param [in] i Index into attribute array
   * \returns The full name associated to the attribute whose index is \p i.
   */
  std::string GetAttributeFullName (std::size_t i) const;

  /**
   * Get the constructor callback.

   *
   * \returns The number of trace sources defined in this TypeId.
   */
  std::size_t GetTraceSourceN (void) const;
  /**
   * Get the trace source by index.
   *
   * \param [in] i Index into trace source array.
   * \returns Detailed information about the requested trace source.
   */
  struct TypeId::TraceSourceInformation GetTraceSource(std::size_t i) const;

  /**
   * Set the parent TypeId.

   * is accessible.
   *
   * \tparam T \explicit The class name represented by this TypeId.
   * \param [in] canBeDupicate If true, this class can be registered more than once
   * \returns This TypeId instance
   */
  template <typename T>
  TypeId AddConstructor (bool canBeDuplicate = false);

  /**
   * Record in this TypeId the fact that a new attribute exists.

   * \param [in] initialValue The new initial value to use for this attribute.
   * \returns \c true if the call was successfuly.
   */
  bool SetAttributeInitialValue(std::size_t i, 
                                Ptr<const AttributeValue> initialValue);

  /**

   *             which class the attribute functional has been moved to,
   *             or that the functionality is no longer supported.
   *             See test file type-id-test-suite.cc for examples.
   * \param [in] canBeDupicate If true, this class can be registered more than once
   * \returns This TypeId instance.
   */
  TypeId AddTraceSource (std::string name,

                         Ptr<const TraceSourceAccessor> accessor,
                         std::string callback,
                         SupportLevel supportLevel = SUPPORTED,
                         const std::string &supportMsg = "",
                         bool canBeDuplicate = false);

  /**
   * Hide this TypeId from documentation.

   * Implementation for AddConstructor().
   *
   * \param [in] callback Callback which constructs an instance of this TypeId.
   * \param [in] canBeDuplicate True if this class can be registered more than once
   */
  void DoAddConstructor (Callback<ObjectBase *> callback, bool canBeDuplicate = false);
  
  /** The TypeId value. */ 
  uint16_t m_tid;


template <typename T>
TypeId 
TypeId::AddConstructor (bool canBeDuplicate)
{
  struct Maker {
    static ObjectBase * Create () {

    }
  };
  Callback<ObjectBase *> cb = MakeCallback (&Maker::Create);
  DoAddConstructor (cb, canBeDuplicate);
  return *this;
}


(-)a/src/core/model/wall-clock-synchronizer.cc (-1 / +1 lines)

Lines 391-397	Link Here

391

392

  NS_LOG_FUNCTION (this << ns << tv);

392

  NS_LOG_FUNCTION (this << ns << tv);

393

  NS_ASSERT ((ns % US_PER_NS) == 0);

393

  NS_ASSERT ((ns % US_PER_NS) == 0);

394

  tv->tv_sec = ns / NS_PER_SEC;

394

  tv->tv_sec = static_cast<long> (ns / NS_PER_SEC);

395

  tv->tv_usec = (ns % NS_PER_SEC) / US_PER_NS;

395

  tv->tv_usec = (ns % NS_PER_SEC) / US_PER_NS;

396

397





bool operator != (const ValueClassTest &a, const ValueClassTest &b)
{
  NS_UNUSED (a);
  NS_UNUSED (b);
  return true;
}
std::ostream & operator << (std::ostream &os, ValueClassTest v)
{
  NS_UNUSED (v);
  return os;
}
std::istream & operator >> (std::istream &is, ValueClassTest &v)
{
  NS_UNUSED (v);
  return is;
}


  bool DoGetTestB (void) const { return m_boolTestA; }
  int16_t DoGetInt16 (void) const { return m_int16SetGet; }
  void DoSetInt16 (int16_t v) { m_int16SetGet = v; }
  std::size_t DoGetVectorN (void) const { return m_vector2.size (); }
  Ptr<Derived> DoGetVector (std::size_t i) const { return m_vector2[i]; }
  bool DoSetIntSrc (int8_t v) { m_intSrc2 = v; return true; }
  int8_t DoGetIntSrc (void) const { return m_intSrc2; }
  bool DoSetEnum (Test_e v) { m_enumSetGet = v; return true; }

private:
  virtual void DoRun (void);

  void NotifySource1 (int8_t old, int8_t n)
  {
    NS_UNUSED (old);
    m_got1 = n;
  }
  int64_t m_got1;
};


private:
  virtual void DoRun (void);

  void NotifySource2 (double a, int b, float c)
  {
    NS_UNUSED (b);
    NS_UNUSED (c);
    m_got2 = a;
  }

  double m_got2;
};

private:
  virtual void DoRun (void);

  void NotifySource2 (double a, int b, float c)
  {
    NS_UNUSED (b);
    NS_UNUSED (c);
    m_got2 = a;
  }

  double m_got2;
};





#include "ns3/test.h"
#include "ns3/callback.h"
#include "ns3/unused.h"
#include <stdint.h>

using namespace ns3;


  void Target1 (void) { m_test1 = true; }
  int Target2 (void) { m_test2 = true; return 2; }
  void Target3 (double a)
  {
    NS_UNUSED (a);
    m_test3 = true;
  }
  int Target4 (double a, int b)
  {
    NS_UNUSED (a);
    NS_UNUSED (b);
    m_test4 = true;
    return 4;
  }

private:
  virtual void DoRun (void);


  void Target1 (void) { m_test1 = true; }
  int Target2 (void) { m_test2 = true; return 2; }
  void Target3 (double a)
  {
    NS_UNUSED (a);
    m_test3 = true;
  }
  int Target4 (double a, int b)
  {
    NS_UNUSED (a);
    NS_UNUSED (b);
    m_test4 = true;
    return 4;
  }

private:
  virtual void DoRun (void);

(-)a/src/core/test/config-test-suite.cc (-2 / +11 lines)

Lines 30-35	Link Here

#include "ns3/names.h"

#include "ns3/names.h"

#include "ns3/pointer.h"

#include "ns3/pointer.h"

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/unused.h"

#include <sstream>

#include <sstream>

Lines 621-627	Link Here

621

   * \param oldValue The old value.

622

   * \param oldValue The old value.

622

   * \param newValue The new value.

623

   * \param newValue The new value.

623

*/

624

*/

624

  void Trace (int16_t oldValue, int16_t newValue) { m_newValue = newValue; }

625

  void Trace (int16_t oldValue, int16_t newValue)

626

627

    NS_UNUSED (oldValue);

628

    m_newValue = newValue;

629

625

/**

630

/**

626

   * Trace callback with context path.

631

   * Trace callback with context path.

627

   * \param path The context path.

632

   * \param path The context path.

Lines 629-635	Link Here

629

   * \param newValue The new value.

634

   * \param newValue The new value.

630

*/

635

*/

631

  void TraceWithPath (std::string path, int16_t old, int16_t newValue)

636

  void TraceWithPath (std::string path, int16_t old, int16_t newValue)

632

  { m_newValue = newValue; m_path = path; }

637

638

    NS_UNUSED (old);

639

    m_newValue = newValue;

640

    m_path = path;

641

633

642

634

private:

643

private:

635

  virtual void DoRun (void);

644

  virtual void DoRun (void);




  if (int64x64_t::implementation == int64x64_t::ld_impl)
    {
      // Darwin 12.5.0 (Mac 10.8.5) g++ 4.2.1
      low = static_cast<uint64_t> (HP_MAX_64 * std::numeric_limits<long double>::epsilon ());
    }

  Check ( 0, 0);

  Check ("-1.0", -1, 0, tolerance);
  Check ("-1.0000", -1, 0, tolerance);
  Check (" 1.000000000000000000054",  1, 1, tolerance);
  Check ("-1.000000000000000000054", (int64_t)-2, (uint64_t)-1, tolerance);
}



  std::cout << GetParent ()->GetName () << " Double: "
	    << "integer: " << intPart
	    << std::endl;
  m_last = static_cast<long double> (intPart);
  m_deltaCount = 0;

  // Nudging the integer part eliminates deltas around 0
  long double v = static_cast<long double> (intPart);
  
  Check (v +0.0000000000000000000542L, intPart,                0x1ULL);
  Check (v +0.0000000000000000001084L, intPart,                0x2ULL);

(-)a/src/core/test/random-variable-stream-test-suite.cc (-4 / +8 lines)

Lines 2603-2609	Link Here

2603

  // There are no simple analytic forms for the Riemann zeta function,

2603

  // There are no simple analytic forms for the Riemann zeta function,

2604

  // which is why the gsl library is used in this test to calculate

2604

  // which is why the gsl library is used in this test to calculate

2605

  // the known mean of the values.

2605

  // the known mean of the values.

2606

  double expectedMean = gsl_sf_zeta_int (alpha - 1) / gsl_sf_zeta_int (alpha);

2606

  double expectedMean =

2607

    gsl_sf_zeta_int (static_cast<int> (alpha - 1)) /

2608

    gsl_sf_zeta_int (static_cast<int> (alpha)        );

2607

2609

2608

  // Test that values have approximately the right mean value.

2610

  // Test that values have approximately the right mean value.

2609

  double TOLERANCE = expectedMean * 1e-2;

2611

  double TOLERANCE = expectedMean * 1e-2;

Lines 2670-2676	Link Here

2670

  // There are no simple analytic forms for the Riemann zeta function,

2672

  // There are no simple analytic forms for the Riemann zeta function,

2671

  // which is why the gsl library is used in this test to calculate

2673

  // which is why the gsl library is used in this test to calculate

2672

  // the known mean of the values.

2674

  // the known mean of the values.

2673

  double expectedMean = gsl_sf_zeta_int (alpha - 1) / gsl_sf_zeta_int (alpha);

2675

  double expectedMean =

2676

    gsl_sf_zeta_int (static_cast<int> (alpha) - 1) /

2677

    gsl_sf_zeta_int (static_cast<int> (alpha)         );

2674

2678

2675

  // Test that values have approximately the right mean value.

2679

  // Test that values have approximately the right mean value.

2676

  double TOLERANCE = expectedMean * 1e-2;

2680

  double TOLERANCE = expectedMean * 1e-2;

Lines 2715-2721	Link Here

2715

  //    4, 4, 7, 7, 10, 10 .

2719

  //    4, 4, 7, 7, 10, 10 .

2716

//

2720

//

2717

  double array1 [] = { 4, 4, 7, 7, 10, 10};

2721

  double array1 [] = { 4, 4, 7, 7, 10, 10};

2718

  uint64_t count1 = 6;

2722

  std::size_t count1 = 6;

2719

  s->SetValueArray (array1, count1);

2723

  s->SetValueArray (array1, count1);

2720

2724

2721

  double value;

2725

  double value;

Lines 2739-2745	Link Here

2739

  //    1000, 2000, 7, 7 .

2743

  //    1000, 2000, 7, 7 .

2740

//

2744

//

2741

  double array2 [] = { 1000, 2000, 3000, 4000};

2745

  double array2 [] = { 1000, 2000, 3000, 4000};

2742

  uint64_t count2 = 4;

2746

  std::size_t count2 = 4;

2743

  s->SetValueArray (array2, count2);

2747

  s->SetValueArray (array2, count2);

2744

2748

2745

  // Test that the second sequence is correct.

2749

  // Test that the second sequence is correct.

(-)a/src/core/test/simulator-test-suite.cc (+2 lines)

Lines 64-69	Link Here

void

void

SimulatorEventsTestCase::EventA (int a)

SimulatorEventsTestCase::EventA (int a)

  NS_UNUSED (a);

  m_a = false;

  m_a = false;

Lines 85-90	Link Here

void

void

SimulatorEventsTestCase::EventC (int c)

SimulatorEventsTestCase::EventC (int c)

  NS_UNUSED (c);

  m_c = false;

  m_c = false;

(-)a/src/core/test/traced-callback-test-suite.cc (+5 lines)

Lines 18-23	Link Here

#include "ns3/test.h"

#include "ns3/test.h"

#include "ns3/traced-callback.h"

#include "ns3/traced-callback.h"

#include "ns3/unused.h"

using namespace ns3;

using namespace ns3;

Lines 45-56	Link Here

void

void

BasicTracedCallbackTestCase::CbOne (uint8_t a, double b)

BasicTracedCallbackTestCase::CbOne (uint8_t a, double b)

  NS_UNUSED (a);

  NS_UNUSED (b);

  m_one = true;

  m_one = true;

void

void

BasicTracedCallbackTestCase::CbTwo (uint8_t a, double b)

BasicTracedCallbackTestCase::CbTwo (uint8_t a, double b)

  NS_UNUSED (a);

  NS_UNUSED (b);

  m_two = true;

  m_two = true;

(-)a/src/lte/examples/lena-intercell-interference.cc (-1 / +1 lines)

Lines 60-66	Link Here

  // determine the string tag that identifies this simulation run

  // determine the string tag that identifies this simulation run

  // this tag is then appended to all filenames

  // this tag is then appended to all filenames

  IntegerValue runValue;

  UintegerValue runValue;

  GlobalValue::GetValueByName ("RngRun", runValue);

  GlobalValue::GetValueByName ("RngRun", runValue);

  std::ostringstream tag;

  std::ostringstream tag;

(-)a/src/lte/examples/lena-pathloss-traces.cc (-1 / +1 lines)

Lines 60-66	Link Here

  // determine the string tag that identifies this simulation run

  // determine the string tag that identifies this simulation run

  // this tag is then appended to all filenames

  // this tag is then appended to all filenames

  IntegerValue runValue;

  UintegerValue runValue;

  GlobalValue::GetValueByName ("RngRun", runValue);

  GlobalValue::GetValueByName ("RngRun", runValue);

  std::ostringstream tag;

  std::ostringstream tag;

(-)a/src/lte/test/lte-test-cell-selection.cc (-1 / +1 lines)

Lines 154-160	Link Here

154

155

  NS_LOG_FUNCTION (this << GetName ());

155

  NS_LOG_FUNCTION (this << GetName ());

156

157

  Config::SetGlobal ("RngRun", IntegerValue (m_rngRun));

157

  Config::SetGlobal ("RngRun", UintegerValue (m_rngRun));

158

159

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

159

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

160

  lteHelper->SetAttribute ("PathlossModel",

160

  lteHelper->SetAttribute ("PathlossModel",

(-)a/src/lte/test/lte-test-phy-error-model.cc (-2 / +2 lines)

Lines 166-172	Link Here

166

  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));

166

  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));

167

  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (true));

167

  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (true));

168

  Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false));

168

  Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false));

169

  Config::SetGlobal ("RngRun", IntegerValue (m_rngRun));

169

  Config::SetGlobal ("RngRun", UintegerValue (m_rngRun));

170

171

  //Disable Uplink Power Control

171

  //Disable Uplink Power Control

172

  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));

172

  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));

Lines 322-328	Link Here

322

  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (true));

322

  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (true));

323

  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));

323

  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));

324

  Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false));

324

  Config::SetDefault ("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue (false));

325

  Config::SetGlobal ("RngRun", IntegerValue (m_rngRun));

325

  Config::SetGlobal ("RngRun", UintegerValue (m_rngRun));

326

327

  //Disable Uplink Power Control

327

  //Disable Uplink Power Control

328

  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));

328

  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));

(-)a/src/lte/test/lte-test-rlc-am-e2e.cc (-1 / +1 lines)

Lines 146-152	Link Here

146

  // LogComponentEnable ("LteRlcUm", level);

146

  // LogComponentEnable ("LteRlcUm", level);

147

  // LogComponentEnable ("LteRlcAm", level);

147

  // LogComponentEnable ("LteRlcAm", level);

148

149

  Config::SetGlobal ("RngRun", IntegerValue (m_run));

149

  Config::SetGlobal ("RngRun", UintegerValue (m_run));

150

  Config::SetDefault ("ns3::LteRlcAm::PollRetransmitTimer", TimeValue (MilliSeconds (20)));

150

  Config::SetDefault ("ns3::LteRlcAm::PollRetransmitTimer", TimeValue (MilliSeconds (20)));

151

  Config::SetDefault ("ns3::LteRlcAm::ReorderingTimer", TimeValue (MilliSeconds (10)));

151

  Config::SetDefault ("ns3::LteRlcAm::ReorderingTimer", TimeValue (MilliSeconds (10)));

152

  Config::SetDefault ("ns3::LteRlcAm::StatusProhibitTimer", TimeValue (MilliSeconds (40)));

152

  Config::SetDefault ("ns3::LteRlcAm::StatusProhibitTimer", TimeValue (MilliSeconds (40)));

(-)a/src/lte/test/lte-test-secondary-cell-selection.cc (-1 / +1 lines)

Lines 92-98	Link Here

  NS_LOG_FUNCTION (this << GetName ());

  NS_LOG_FUNCTION (this << GetName ());

  Config::SetGlobal ("RngRun", IntegerValue (m_rngRun));

  Config::SetGlobal ("RngRun", UintegerValue (m_rngRun));

  // Create helpers.

  // Create helpers.

  auto lteHelper = CreateObject<LteHelper> ();

  auto lteHelper = CreateObject<LteHelper> ();

Return to bug 2726