SunnyQjm
/
ns-3-dev
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

member variables coding style change

ndnSIM-v1
Mathieu Lacage 19 years ago
parent
2329966acc
commit
778ca40af3
21 changed files with 261 additions and 261 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      samples/main-packet.cc
  2. 182
      src/common/buffer.cc
  3. 64
      src/common/buffer.h
  4. 8
      src/common/chunk.cc
  5. 2
      src/common/chunk.h
  6. 4
      src/common/pcap-writer.cc
  7. 2
      src/common/pcap-writer.h
  8. 52
      src/common/trace-container.cc
  9. 20
      src/common/trace-container.h
  10. 18
      src/core/callback.h
  11. 22
      src/core/reference-list.h
  12. 12
      src/core/unix-system-wall-clock-ms.cc
  13. 6
      src/simulator/event-id.cc
  14. 2
      src/simulator/event-id.h
  15. 6
      src/simulator/event-impl.cc
  16. 2
      src/simulator/event-impl.h
  17. 68
      src/simulator/simulator.cc
  18. 4
      src/simulator/simulator.h
  19. 10
      src/simulator/time.cc
  20. 2
      src/simulator/time.h
  21. 32
      utils/replay-simulation.cc

4
samples/main-packet.cc
Unescape View File

@ -69,7 +69,7 @@ MyChunk::get_data (void) const
/* A sample Tag implementation
*/
struct MyTag {
uint16_t m_stream_id;
uint16_t m_streamId;
};
@ -93,7 +93,7 @@ int main (int argc, char *argv[])
std::cout << "send data=2" << std::endl;
p.add (&my);
struct MyTag my_tag;
my_tag.m_stream_id = 5;
my_tag.m_streamId = 5;
p.add_tag (&my_tag);
receive (p);
return 0;

182
src/common/buffer.cc
Unescape View File

@ -27,9 +27,9 @@
namespace ns3 {
Buffer::BufferDataList Buffer::m_free_list;
uint32_t Buffer::m_max_total_add_start = 0;
uint32_t Buffer::m_max_total_add_end = 0;
Buffer::BufferDataList Buffer::m_freeList;
uint32_t Buffer::m_maxTotalAddStart = 0;
uint32_t Buffer::m_maxTotalAddEnd = 0;
struct Buffer::BufferData *
Buffer::allocate (uint32_t req_size, uint32_t req_start)
@ -42,9 +42,9 @@ Buffer::allocate (uint32_t req_size, uint32_t req_start)
uint8_t *b = new uint8_t [size];
struct BufferData *data = reinterpret_cast<struct Buffer::BufferData*>(b);
data->m_size = req_size;
data->m_initial_start = req_start;
data->m_dirty_start = req_start;
data->m_dirty_size = 0;
data->m_initialStart = req_start;
data->m_dirtyStart = req_start;
data->m_dirtySize = 0;
data->m_count = 1;
return data;
}
@ -61,15 +61,15 @@ Buffer::recycle (struct Buffer::BufferData *data)
{
assert (data->m_count == 0);
/* get rid of it if it is too small for later reuse. */
if (data->m_size < (Buffer::m_max_total_add_start + Buffer::m_max_total_add_end)) {
if (data->m_size < (Buffer::m_maxTotalAddStart + Buffer::m_maxTotalAddEnd)) {
Buffer::deallocate (data);
return;
}
/* feed into free list */
if (Buffer::m_free_list.size () > 1000) {
if (Buffer::m_freeList.size () > 1000) {
Buffer::deallocate (data);
} else {
Buffer::m_free_list.push_back (data);
Buffer::m_freeList.push_back (data);
}
}
@ -77,20 +77,20 @@ Buffer::BufferData *
Buffer::create (void)
{
/* try to find a buffer correctly sized. */
while (!Buffer::m_free_list.empty ()) {
struct Buffer::BufferData *data = Buffer::m_free_list.back ();
Buffer::m_free_list.pop_back ();
if (data->m_size >= (m_max_total_add_start + m_max_total_add_end)) {
data->m_initial_start = m_max_total_add_start;
data->m_dirty_start = m_max_total_add_start;
data->m_dirty_size = 0;
while (!Buffer::m_freeList.empty ()) {
struct Buffer::BufferData *data = Buffer::m_freeList.back ();
Buffer::m_freeList.pop_back ();
if (data->m_size >= (m_maxTotalAddStart + m_maxTotalAddEnd)) {
data->m_initialStart = m_maxTotalAddStart;
data->m_dirtyStart = m_maxTotalAddStart;
data->m_dirtySize = 0;
data->m_count = 1;
return data;
}
Buffer::deallocate (data);
}
struct Buffer::BufferData *data = Buffer::allocate (m_max_total_add_start+m_max_total_add_end,
m_max_total_add_start);
struct Buffer::BufferData *data = Buffer::allocate (m_maxTotalAddStart+m_maxTotalAddEnd,
m_maxTotalAddStart);
assert (data->m_count == 1);
return data;
}
@ -104,8 +104,8 @@ Buffer::recycle (struct Buffer::BufferData *data)
Buffer::BufferData *
Buffer::create (void)
{
return Buffer::allocate (m_max_total_add_start+m_max_total_add_end,
m_max_total_add_start);
return Buffer::allocate (m_maxTotalAddStart+m_maxTotalAddEnd,
m_maxTotalAddStart);
}
#endif
@ -120,8 +120,8 @@ namespace ns3 {
void
Buffer::add_at_start (uint32_t start)
{
assert (m_start <= m_data->m_initial_start);
bool is_dirty = m_data->m_count > 1 && m_start > m_data->m_dirty_start;
assert (m_start <= m_data->m_initialStart);
bool is_dirty = m_data->m_count > 1 && m_start > m_data->m_dirtyStart;
if (m_start >= start && !is_dirty) {
/* enough space in the buffer and not dirty. */
m_start -= start;
@ -130,7 +130,7 @@ Buffer::add_at_start (uint32_t start)
/* enough space but need to move data around to fit new data */
memmove (m_data->m_data + start, get_start (), m_size);
assert (start > m_start);
m_data->m_initial_start += start;
m_data->m_initialStart += start;
m_start = 0;
m_size += start;
} else if (m_start < start) {
@ -138,7 +138,7 @@ Buffer::add_at_start (uint32_t start)
uint32_t new_size = m_size + start;
struct Buffer::BufferData *new_data = Buffer::allocate (new_size, 0);
memcpy (new_data->m_data + start, get_start (), m_size);
new_data->m_initial_start = m_data->m_initial_start + start;
new_data->m_initialStart = m_data->m_initialStart + start;
m_data->m_count--;
if (m_data->m_count == 0) {
Buffer::deallocate (m_data);
@ -151,7 +151,7 @@ Buffer::add_at_start (uint32_t start)
assert (is_dirty);
struct Buffer::BufferData *new_data = Buffer::create ();
memcpy (new_data->m_data + m_start, get_start (), m_size);
new_data->m_initial_start = m_data->m_initial_start;
new_data->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
recycle (m_data);
@ -161,28 +161,28 @@ Buffer::add_at_start (uint32_t start)
m_size += start;
}
// update dirty area
m_data->m_dirty_start = m_start;
m_data->m_dirty_size = m_size;
// update m_max_total_add_start
m_data->m_dirtyStart = m_start;
m_data->m_dirtySize = m_size;
// update m_maxTotalAddStart
uint32_t added_at_start;
if (m_data->m_initial_start > m_start) {
added_at_start = m_data->m_initial_start - m_start;
if (m_data->m_initialStart > m_start) {
added_at_start = m_data->m_initialStart - m_start;
} else {
added_at_start = 0;
}
if (added_at_start > m_max_total_add_start) {
m_max_total_add_start = added_at_start;
if (added_at_start > m_maxTotalAddStart) {
m_maxTotalAddStart = added_at_start;
}
TRACE ("start add="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
TRACE ("start add="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
void
Buffer::add_at_end (uint32_t end)
{
assert (m_start <= m_data->m_initial_start);
assert (m_start <= m_data->m_initialStart);
bool is_dirty = m_data->m_count > 1 &&
m_start + m_size < m_data->m_dirty_start + m_data->m_dirty_size;
m_start + m_size < m_data->m_dirtyStart + m_data->m_dirtySize;
if (m_start + m_size + end <= m_data->m_size && !is_dirty) {
/* enough space in buffer and not dirty */
m_size += end;
@ -191,7 +191,7 @@ Buffer::add_at_end (uint32_t end)
uint32_t new_start = m_data->m_size - (m_size + end);
memmove (m_data->m_data + new_start, get_start (), m_size);
assert (new_start < m_start);
m_data->m_initial_start -= m_start - new_start;
m_data->m_initialStart -= m_start - new_start;
m_start = new_start;
m_size += end;
} else if (m_start + m_size + end > m_data->m_size) {
@ -199,7 +199,7 @@ Buffer::add_at_end (uint32_t end)
uint32_t new_size = m_size + end;
struct Buffer::BufferData *new_data = Buffer::allocate (new_size, 0);
memcpy (new_data->m_data, get_start (), m_size);
new_data->m_initial_start = m_data->m_initial_start;
new_data->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
Buffer::deallocate (m_data);
@ -212,7 +212,7 @@ Buffer::add_at_end (uint32_t end)
assert (is_dirty);
struct Buffer::BufferData *new_data = Buffer::create ();
memcpy (new_data->m_data + m_start, get_start (), m_size);
new_data->m_initial_start = m_data->m_initial_start;
new_data->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
recycle (m_data);
@ -221,28 +221,28 @@ Buffer::add_at_end (uint32_t end)
m_size += end;
}
// update dirty area
m_data->m_dirty_start = m_start;
m_data->m_dirty_size = m_size;
// update m_max_total_add_end
m_data->m_dirtyStart = m_start;
m_data->m_dirtySize = m_size;
// update m_maxTotalAddEnd
uint32_t end_loc = m_start + m_size;
uint32_t added_at_end;
if (m_data->m_initial_start < end_loc) {
added_at_end = end_loc - m_data->m_initial_start;
if (m_data->m_initialStart < end_loc) {
added_at_end = end_loc - m_data->m_initialStart;
} else {
added_at_end = 0;
}
if (added_at_end > m_max_total_add_end) {
m_max_total_add_end = added_at_end;
if (added_at_end > m_maxTotalAddEnd) {
m_maxTotalAddEnd = added_at_end;
}
TRACE ("end add="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
TRACE ("end add="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
void
Buffer::remove_at_start (uint32_t start)
{
if (m_zero_area_size == 0) {
if (m_zeroAreaSize == 0) {
if (m_size <= start) {
m_start += m_size;
m_size = 0;
@ -251,10 +251,10 @@ Buffer::remove_at_start (uint32_t start)
m_size -= start;
}
} else {
assert (m_data->m_initial_start >= m_start);
uint32_t zero_start = m_data->m_initial_start - m_start;
uint32_t zero_end = zero_start + m_zero_area_size;
uint32_t data_end = m_size + m_zero_area_size;
assert (m_data->m_initialStart >= m_start);
uint32_t zero_start = m_data->m_initialStart - m_start;
uint32_t zero_end = zero_start + m_zeroAreaSize;
uint32_t data_end = m_size + m_zeroAreaSize;
if (start <= zero_start) {
/* only remove start of buffer */
m_start += start;
@ -263,76 +263,76 @@ Buffer::remove_at_start (uint32_t start)
/* remove start of buffer _and_ start of zero area */
m_start += zero_start;
uint32_t zero_delta = start - zero_start;
m_zero_area_size -= zero_delta;
m_zeroAreaSize -= zero_delta;
assert (zero_delta <= start);
m_size -= zero_start;
} else if (start <= data_end) {
/* remove start of buffer, complete zero area, and part
* of end of buffer */
m_start += start - m_zero_area_size;
m_size -= start - m_zero_area_size;
m_zero_area_size = 0;
m_start += start - m_zeroAreaSize;
m_size -= start - m_zeroAreaSize;
m_zeroAreaSize = 0;
} else {
/* remove all buffer */
m_start += m_size;
m_size = 0;
m_zero_area_size = 0;
m_zeroAreaSize = 0;
}
}
TRACE ("start remove="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
TRACE ("start remove="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
void
Buffer::remove_at_end (uint32_t end)
{
if (m_zero_area_size == 0) {
if (m_zeroAreaSize == 0) {
if (m_size <= end) {
m_size = 0;
} else {
m_size -= end;
}
} else {
assert (m_data->m_initial_start >= m_start);
uint32_t zero_start = m_data->m_initial_start - m_start;
uint32_t zero_end = zero_start + m_zero_area_size;
uint32_t data_end = m_size + m_zero_area_size;
assert (m_data->m_initialStart >= m_start);
uint32_t zero_start = m_data->m_initialStart - m_start;
uint32_t zero_end = zero_start + m_zeroAreaSize;
uint32_t data_end = m_size + m_zeroAreaSize;
assert (zero_start <= m_size);
assert (zero_end <= m_size + m_zero_area_size);
assert (zero_end <= m_size + m_zeroAreaSize);
if (data_end <= end) {
/* remove all buffer */
m_zero_area_size = 0;
m_zeroAreaSize = 0;
m_start += m_size;
m_size = 0;
} else if (data_end - zero_start <= end) {
/* remove end of buffer, zero area, part of start of buffer */
assert (end >= m_zero_area_size);
m_size -= end - m_zero_area_size;
m_zero_area_size = 0;
assert (end >= m_zeroAreaSize);
m_size -= end - m_zeroAreaSize;
m_zeroAreaSize = 0;
} else if (data_end - zero_end <= end) {
/* remove end of buffer, part of zero area */
uint32_t zero_delta = end - (data_end - zero_end);
m_zero_area_size -= zero_delta;
m_zeroAreaSize -= zero_delta;
m_size -= end - zero_delta;
} else {
/* remove part of end of buffer */
m_size -= end;
}
}
TRACE ("end remove="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
TRACE ("end remove="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
Buffer
Buffer::create_fragment (uint32_t start, uint32_t length) const
{
uint32_t zero_start = m_data->m_initial_start - m_start;
uint32_t zero_end = zero_start + m_zero_area_size;
if (m_zero_area_size != 0 &&
uint32_t zero_start = m_data->m_initialStart - m_start;
uint32_t zero_end = zero_start + m_zeroAreaSize;
if (m_zeroAreaSize != 0 &&
start + length > zero_start &&
start <= zero_end) {
transform_into_real_buffer ();
transform_intoRealBuffer ();
}
Buffer tmp = *this;
tmp.remove_at_start (start);
@ -341,22 +341,22 @@ Buffer::create_fragment (uint32_t start, uint32_t length) const
}
void
Buffer::transform_into_real_buffer (void) const
Buffer::transform_intoRealBuffer (void) const
{
if (m_zero_area_size != 0) {
assert (m_data->m_initial_start >= m_start);
assert (m_size >= (m_data->m_initial_start - m_start));
if (m_zeroAreaSize != 0) {
assert (m_data->m_initialStart >= m_start);
assert (m_size >= (m_data->m_initialStart - m_start));
Buffer tmp;
tmp.add_at_start (m_zero_area_size);
tmp.begin ().write_u8 (0, m_zero_area_size);
uint32_t data_start = m_data->m_initial_start - m_start;
tmp.add_at_start (m_zeroAreaSize);
tmp.begin ().write_u8 (0, m_zeroAreaSize);
uint32_t data_start = m_data->m_initialStart - m_start;
tmp.add_at_start (data_start);
tmp.begin ().write (m_data->m_data+m_start, data_start);
uint32_t data_end = m_size - (m_data->m_initial_start - m_start);
uint32_t data_end = m_size - (m_data->m_initialStart - m_start);
tmp.add_at_end (data_end);
Buffer::Iterator i = tmp.end ();
i.prev (data_end);
i.write (m_data->m_data+m_data->m_initial_start,data_end);
i.write (m_data->m_data+m_data->m_initialStart,data_end);
*const_cast<Buffer *> (this) = tmp;
}
}
@ -365,7 +365,7 @@ Buffer::transform_into_real_buffer (void) const
uint8_t *
Buffer::peek_data (void) const
{
transform_into_real_buffer ();
transform_intoRealBuffer ();
return m_data->m_data + m_start;
}

64
src/common/buffer.h
Unescape View File

@ -240,9 +240,9 @@ public:
friend class Buffer;
inline Iterator (Buffer const*buffer, uint32_t m_current);
inline uint32_t get_index (uint32_t n);
uint32_t m_zero_start;
uint32_t m_zero_end;
uint32_t m_data_end;
uint32_t m_zeroStart;
uint32_t m_zeroEnd;
uint32_t m_dataEnd;
uint32_t m_current;
uint8_t *m_data;
};
@ -329,26 +329,26 @@ private:
struct BufferData {
uint32_t m_count;
uint32_t m_size;
uint32_t m_initial_start;
uint32_t m_dirty_start;
uint32_t m_dirty_size;
uint32_t m_initialStart;
uint32_t m_dirtyStart;
uint32_t m_dirtySize;
uint8_t m_data[1];
};
typedef std::vector<struct Buffer::BufferData*> BufferDataList;
inline uint8_t *get_start (void) const;
void transform_into_real_buffer (void) const;
void transform_intoRealBuffer (void) const;
static void recycle (struct Buffer::BufferData *data);
static struct Buffer::BufferData *create (void);
static struct Buffer::BufferData *allocate (uint32_t size, uint32_t start);
static void deallocate (struct Buffer::BufferData *data);
static BufferDataList m_free_list;
static uint32_t m_max_total_add_start;
static uint32_t m_max_total_add_end;
static BufferDataList m_freeList;
static uint32_t m_maxTotalAddStart;
static uint32_t m_maxTotalAddEnd;
struct BufferData *m_data;
uint32_t m_zero_area_size;
uint32_t m_zeroAreaSize;
uint32_t m_start;
uint32_t m_size;
};
@ -361,8 +361,8 @@ namespace ns3 {
Buffer::Buffer ()
: m_data (Buffer::create ()),
m_zero_area_size (0),
m_start (m_max_total_add_start),
m_zeroAreaSize (0),
m_start (m_maxTotalAddStart),
m_size (0)
{
if (m_start > m_data->m_size) {
@ -373,8 +373,8 @@ Buffer::Buffer ()
Buffer::Buffer (uint32_t data_size)
: m_data (Buffer::create ()),
m_zero_area_size (data_size),
m_start (m_max_total_add_start),
m_zeroAreaSize (data_size),
m_start (m_maxTotalAddStart),
m_size (0)
{
if (m_start > m_data->m_size) {
@ -386,7 +386,7 @@ Buffer::Buffer (uint32_t data_size)
Buffer::Buffer (Buffer const&o)
: m_data (o.m_data),
m_zero_area_size (o.m_zero_area_size),
m_zeroAreaSize (o.m_zeroAreaSize),
m_start (o.m_start),
m_size (o.m_size)
{
@ -406,7 +406,7 @@ Buffer::operator = (Buffer const&o)
m_data = o.m_data;
m_data->m_count++;
}
m_zero_area_size = o.m_zero_area_size;
m_zeroAreaSize = o.m_zeroAreaSize;
m_start = o.m_start;
m_size = o.m_size;
assert (m_start <= m_data->m_size);
@ -431,7 +431,7 @@ Buffer::get_start (void) const
uint32_t
Buffer::get_size (void) const
{
return m_size + m_zero_area_size;
return m_size + m_zeroAreaSize;
}
Buffer::Iterator
@ -447,16 +447,16 @@ Buffer::end (void) const
Buffer::Iterator::Iterator ()
: m_zero_start (0),
m_zero_end (0),
m_data_end (0),
: m_zeroStart (0),
m_zeroEnd (0),
m_dataEnd (0),
m_current (0),
m_data (0)
{}
Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)
: m_zero_start (buffer->m_data->m_initial_start-buffer->m_start),
m_zero_end (m_zero_start+buffer->m_zero_area_size),
m_data_end (buffer->get_size ()),
: m_zeroStart (buffer->m_data->m_initialStart-buffer->m_start),
m_zeroEnd (m_zeroStart+buffer->m_zeroAreaSize),
m_dataEnd (buffer->get_size ()),
m_current (current),
m_data (buffer->m_data->m_data+buffer->m_start)
{}
@ -464,7 +464,7 @@ Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)
void
Buffer::Iterator::next (void)
{
assert (m_current + 1 <= m_data_end);
assert (m_current + 1 <= m_dataEnd);
m_current++;
}
void
@ -476,7 +476,7 @@ Buffer::Iterator::prev (void)
void
Buffer::Iterator::next (uint32_t delta)
{
assert (m_current + delta <= m_data_end);
assert (m_current + delta <= m_dataEnd);
m_current += delta;
}
void
@ -497,7 +497,7 @@ Buffer::Iterator::get_distance_from (Iterator const &o) const
bool
Buffer::Iterator::is_end (void) const
{
return m_current == m_data_end;
return m_current == m_dataEnd;
}
bool
Buffer::Iterator::is_start (void) const
@ -509,15 +509,15 @@ uint32_t
Buffer::Iterator::get_index (uint32_t n)
{
assert (
(m_current + n <= m_data_end) &&
((m_current + n <= m_zero_start) ||
(m_current >= m_zero_end))
(m_current + n <= m_dataEnd) &&
((m_current + n <= m_zeroStart) ||
(m_current >= m_zeroEnd))
);
uint32_t index;
if (m_current < m_zero_start) {
if (m_current < m_zeroStart) {
index = m_current;
} else {
index = m_current - (m_zero_end-m_zero_start);
index = m_current - (m_zeroEnd-m_zeroStart);
}
return index;
}

8
src/common/chunk.cc
Unescape View File

@ -25,7 +25,7 @@
namespace ns3 {
Chunk::Chunk ()
: m_must_peek_before_remove (false) {}
: m_mustPeekBeforeRemove (false) {}
void
Chunk::print (std::ostream &os) const
@ -41,14 +41,14 @@ void
Chunk::peek (Buffer const *buffer)
{
peek_from (buffer);
m_must_peek_before_remove = true;
m_mustPeekBeforeRemove = true;
}
void
Chunk::remove (Buffer *buffer)
{
assert (m_must_peek_before_remove);
assert (m_mustPeekBeforeRemove);
remove_from (buffer);
m_must_peek_before_remove = false;
m_mustPeekBeforeRemove = false;
}

2
src/common/chunk.h
Unescape View File

@ -49,7 +49,7 @@ public:
void peek (Buffer const *buffer);
void remove (Buffer *buffer);
private:
bool m_must_peek_before_remove;
bool m_mustPeekBeforeRemove;
/**
* \param os the std output stream in which this
* protocol header must print itself.

4
src/common/pcap-writer.cc
Unescape View File

@ -39,7 +39,7 @@ enum {
PcapWriter::PcapWriter ()
{
m_writer = 0;
m_write_callback = make_callback (&PcapWriter::write_data, this);
m_writeCallback = make_callback (&PcapWriter::write_data, this);
}
PcapWriter::~PcapWriter ()
{
@ -76,7 +76,7 @@ PcapWriter::write_packet (Packet const packet)
write_32 (us & 0xffffffff);
write_32 (packet.get_size ());
write_32 (packet.get_size ());
packet.write (m_write_callback);
packet.write (m_writeCallback);
}
}

2
src/common/pcap-writer.h
Unescape View File

@ -65,7 +65,7 @@ private:
void write_32 (uint32_t data);
void write_16 (uint16_t data);
SystemFile *m_writer;
Callback<void,uint8_t *,uint32_t> m_write_callback;
Callback<void,uint8_t *,uint32_t> m_writeCallback;
};
}; // namespace ns3

52
src/common/trace-container.cc
Unescape View File

@ -30,15 +30,15 @@ TraceContainer::TraceContainer ()
{}
TraceContainer::~TraceContainer ()
{
m_ui_list.erase (m_ui_list.begin (), m_ui_list.end ());
m_si_list.erase (m_si_list.begin (), m_si_list.end ());
m_f_list.erase (m_f_list.begin (), m_f_list.end ());
m_uiList.erase (m_uiList.begin (), m_uiList.end ());
m_siList.erase (m_siList.begin (), m_siList.end ());
m_fList.erase (m_fList.begin (), m_fList.end ());
}
void
TraceContainer::set_ui_variable_callback (char const *name, Callback<void,uint64_t, uint64_t> callback)
{
for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
if ((*i).second == name) {
(*i).first->set_callback (callback);
return;
@ -49,7 +49,7 @@ TraceContainer::set_ui_variable_callback (char const *name, Callback<void,uint64
void
TraceContainer::set_si_variable_callback (char const *name, Callback<void,int64_t, int64_t> callback)
{
for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
if ((*i).second == name) {
(*i).first->set_callback (callback);
return;
@ -65,7 +65,7 @@ TraceContainer::set_f_variable_callback (char const *name, Callback<void,double,
void
TraceContainer::set_stream (char const *name, std::ostream *os)
{
for (StreamTracerListI i = m_trace_stream_list.begin (); i != m_trace_stream_list.end (); i++) {
for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
if ((*i).second == name) {
(*i).first->set_stream (os);
return;
@ -78,25 +78,25 @@ void
TraceContainer::register_ui_variable (char const *name, UiVariableTracerBase *var)
{
// ensure unicity
for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
if (i->second == name) {
m_ui_list.erase (i);
m_uiList.erase (i);
break;
}
}
m_ui_list.push_back (std::make_pair (var, name));
m_uiList.push_back (std::make_pair (var, name));
}
void
TraceContainer::register_si_variable (char const *name, SiVariableTracerBase *var)
{
// ensure unicity
for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
if (i->second == name) {
m_si_list.erase (i);
m_siList.erase (i);
break;
}
}
m_si_list.push_back (std::make_pair (var, name));
m_siList.push_back (std::make_pair (var, name));
}
void
TraceContainer::register_f_variable (char const *name, FVariableTracerBase *var)
@ -108,26 +108,26 @@ void
TraceContainer::register_stream (char const *name, StreamTracer *stream)
{
// ensure unicity
for (StreamTracerListI i = m_trace_stream_list.begin (); i != m_trace_stream_list.end (); i++) {
for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
if (i->second == name) {
m_trace_stream_list.erase (i);
m_traceStreamList.erase (i);
break;
}
}
m_trace_stream_list.push_back (std::make_pair (stream,name));
m_traceStreamList.push_back (std::make_pair (stream,name));
}
void
TraceContainer::register_callback (char const *name, CallbackTracerBase *tracer)
{
for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
m_callback_list.erase (i);
m_callbackList.erase (i);
break;
}
}
m_callback_list.push_back (std::make_pair (tracer, name));
m_callbackList.push_back (std::make_pair (tracer, name));
}
@ -139,27 +139,27 @@ TraceContainer::register_callback (char const *name, CallbackTracerBase *tracer)
void
ns3::TraceContainer::print_debug (void)
{
if (!m_ui_list.empty ()) {
if (!m_uiList.empty ()) {
std::cout << "ui var: " << std::endl;
for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
if (!m_si_list.empty ()) {
if (!m_siList.empty ()) {
std::cout << "si var: " << std::endl;
for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
if (!m_f_list.empty ()) {
if (!m_fList.empty ()) {
std::cout << "f var: " << std::endl;
for (FListI i = m_f_list.begin (); i != m_f_list.end (); i++) {
for (FListI i = m_fList.begin (); i != m_fList.end (); i++) {
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
if (!m_callback_list.empty ()) {
if (!m_callbackList.empty ()) {
std::cout << "callback list: "<<std::endl;
for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
std::cout << " \"" << i->second << "\""<<std::endl;
}
}

20
src/common/trace-container.h
Unescape View File

@ -187,11 +187,11 @@ private:
typedef std::list<std::pair<CallbackTracerBase *, std::string> > CallbackList;
typedef std::list<std::pair<CallbackTracerBase *, std::string> >::iterator CallbackListI;
UiList m_ui_list;
SiList m_si_list;
FList m_f_list;
StreamTracerList m_trace_stream_list;
CallbackList m_callback_list;
UiList m_uiList;
SiList m_siList;
FList m_fList;
StreamTracerList m_traceStreamList;
CallbackList m_callbackList;
};
}; // namespace ns3
@ -206,7 +206,7 @@ template <typename T1>
void
TraceContainer::set_callback (char const *name, Callback<void,T1> callback)
{
for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1> *> (i->first)->set_callback (callback);
return;
@ -220,7 +220,7 @@ template <typename T1, typename T2>
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2> callback)
{
for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2> *> (i->first)->set_callback (callback);
return;
@ -234,7 +234,7 @@ template <typename T1, typename T2, typename T3>
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3> callback)
{
for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2,T3> *> (i->first)->set_callback (callback);
return;
@ -248,7 +248,7 @@ template <typename T1, typename T2, typename T3, typename T4>
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3,T4> callback)
{
for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2,T3,T4> *> (i->first)->set_callback (callback);
return;
@ -262,7 +262,7 @@ template <typename T1, typename T2, typename T3, typename T4, typename T5>
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3,T4,T5> callback)
{
for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2,T3,T4,T5> *> (i->first)->set_callback (callback);
return;

18
src/core/callback.h
Unescape View File

@ -169,29 +169,29 @@ template <typename OBJ_PTR, typename MEM_PTR, typename R, typename T1, typename
class MemPtrCallbackImpl : public CallbackImpl<R,T1,T2,T3,T4,T5> {
public:
MemPtrCallbackImpl (OBJ_PTR const&obj_ptr, MEM_PTR mem_ptr)
: m_obj_ptr (obj_ptr), m_mem_ptr (mem_ptr) {}
: m_objPtr (obj_ptr), m_memPtr (mem_ptr) {}
virtual ~MemPtrCallbackImpl () {}
R operator() (void) {
return ((*m_obj_ptr).*m_mem_ptr) ();
return ((*m_objPtr).*m_memPtr) ();
}
R operator() (T1 a1) {
return ((*m_obj_ptr).*m_mem_ptr) (a1);
return ((*m_objPtr).*m_memPtr) (a1);
}
R operator() (T1 a1,T2 a2) {
return ((*m_obj_ptr).*m_mem_ptr) (a1,a2);
return ((*m_objPtr).*m_memPtr) (a1,a2);
}
R operator() (T1 a1,T2 a2,T3 a3) {
return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3);
return ((*m_objPtr).*m_memPtr) (a1,a2,a3);
}
R operator() (T1 a1,T2 a2,T3 a3,T4 a4) {
return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3,a4);
return ((*m_objPtr).*m_memPtr) (a1,a2,a3,a4);
}
R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5) {
return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3,a4,a5);
return ((*m_objPtr).*m_memPtr) (a1,a2,a3,a4,a5);
}
private:
OBJ_PTR const m_obj_ptr;
MEM_PTR m_mem_ptr;
OBJ_PTR const m_objPtr;
MEM_PTR m_memPtr;
};
/**

22
src/core/reference-list.h
Unescape View File

@ -38,7 +38,7 @@ template <typename OBJ_PTR>
class ReferenceList {
public:
ReferenceList ()
: m_obj_ptr (),
: m_objPtr (),
m_prev (),
m_next ()
{
@ -46,7 +46,7 @@ public:
m_next = this;
}
ReferenceList (ReferenceList &o)
: m_obj_ptr (),
: m_objPtr (),
m_prev (),
m_next ()
{
@ -55,7 +55,7 @@ public:
insert_self_in_other (o);
}
ReferenceList (ReferenceList const&o)
: m_obj_ptr (),
: m_objPtr (),
m_prev (),
m_next ()
{
@ -64,7 +64,7 @@ public:
insert_self_in_other (o);
}
ReferenceList (OBJ_PTR const &obj_ptr)
: m_obj_ptr (obj_ptr),
: m_objPtr (obj_ptr),
m_prev (),
m_next ()
{
@ -80,15 +80,15 @@ public:
return *this;
}
OBJ_PTR operator-> () {
return m_obj_ptr;
return m_objPtr;
}
void set (OBJ_PTR obj_ptr) {
remove_from_list ();
m_obj_ptr = obj_ptr;
m_objPtr = obj_ptr;
}
OBJ_PTR get (void) {
// explicit conversion to raw pointer type.
return m_obj_ptr;
return m_objPtr;
}
private:
void insert_self_in_other (ReferenceList const&o) {
@ -96,18 +96,18 @@ private:
m_next = o.m_next;
m_next->m_prev = this;
o.m_next = this;
m_obj_ptr = o.m_obj_ptr;
m_objPtr = o.m_objPtr;
}
void remove_from_list (void) {
if (m_prev == this) {
//assert (m_next == this);
delete m_obj_ptr;
m_obj_ptr = OBJ_PTR ();
delete m_objPtr;
m_objPtr = OBJ_PTR ();
}
m_prev->m_next = m_next;
m_next->m_prev = m_prev;
}
OBJ_PTR m_obj_ptr;
OBJ_PTR m_objPtr;
mutable ReferenceList const*m_prev;
mutable ReferenceList const*m_next;
};

12
src/core/unix-system-wall-clock-ms.cc
Unescape View File

@ -29,24 +29,24 @@ public:
void start (void);
unsigned long long end (void);
private:
struct timeval m_start_tv;
struct timeval m_end_tv;
struct timeval m_startTv;
struct timeval m_endTv;
};
void
SystemWallClockMsPrivate::start (void)
{
struct timezone tz;
gettimeofday (&m_start_tv, &tz);
gettimeofday (&m_startTv, &tz);
}
unsigned long long
SystemWallClockMsPrivate::end (void)
{
struct timezone tz;
gettimeofday (&m_end_tv, &tz);
unsigned long long end = m_end_tv.tv_sec *1000 + m_end_tv.tv_usec / 1000;
unsigned long long start = m_start_tv.tv_sec *1000 + m_start_tv.tv_usec / 1000;
gettimeofday (&m_endTv, &tz);
unsigned long long end = m_endTv.tv_sec *1000 + m_endTv.tv_usec / 1000;
unsigned long long start = m_startTv.tv_sec *1000 + m_startTv.tv_usec / 1000;
return end - start;
}

6
src/simulator/event-id.cc
Unescape View File

@ -24,13 +24,13 @@
namespace ns3 {
EventId::EventId ()
: m_event_impl (0),
: m_eventImpl (0),
m_ns (0),
m_uid (0)
{}
EventId::EventId (EventImpl *impl, uint64_t ns, uint32_t uid)
: m_event_impl (impl),
: m_eventImpl (impl),
m_ns (ns),
m_uid (uid)
{}
@ -47,7 +47,7 @@ EventId::is_expired (void)
EventImpl *
EventId::get_event_impl (void) const
{
return m_event_impl;
return m_eventImpl;
}
uint64_t
EventId::get_ns (void) const

2
src/simulator/event-id.h
Unescape View File

@ -42,7 +42,7 @@ public:
uint64_t get_ns (void) const;
uint32_t get_uid (void) const;
private:
EventImpl *m_event_impl;
EventImpl *m_eventImpl;
uint64_t m_ns;
uint32_t m_uid;
};

6
src/simulator/event-impl.cc
Unescape View File

@ -29,7 +29,7 @@ EventImpl::~EventImpl ()
{}
EventImpl::EventImpl ()
: m_internal_iterator (0),
: m_internalIterator (0),
m_cancel (false)
{}
void
@ -42,12 +42,12 @@ EventImpl::invoke (void)
void
EventImpl::set_internal_iterator (void *tag)
{
m_internal_iterator = tag;
m_internalIterator = tag;
}
void *
EventImpl::get_internal_iterator (void) const
{
return m_internal_iterator;
return m_internalIterator;
}
void
EventImpl::cancel (void)

2
src/simulator/event-impl.h
Unescape View File

@ -37,7 +37,7 @@ protected:
virtual void notify (void) = 0;
private:
friend class Event;
void *m_internal_iterator;
void *m_internalIterator;
bool m_cancel;
};

68
src/simulator/simulator.cc
Unescape View File

@ -70,15 +70,15 @@ private:
typedef std::list<std::pair<EventImpl *,uint32_t> > Events;
Events m_destroy;
uint64_t m_stop_at;
uint64_t m_stopAt;
bool m_stop;
Scheduler *m_events;
uint32_t m_uid;
uint32_t m_current_uid;
uint64_t m_current_ns;
uint32_t m_currentUid;
uint64_t m_currentNs;
std::ofstream m_log;
std::ifstream m_input_log;
bool m_log_enable;
std::ifstream m_inputLog;
bool m_logEnable;
};
@ -87,11 +87,11 @@ private:
SimulatorPrivate::SimulatorPrivate (Scheduler *events)
{
m_stop = false;
m_stop_at = 0;
m_stopAt = 0;
m_events = events;
m_uid = 0;
m_log_enable = false;
m_current_ns = 0;
m_logEnable = false;
m_currentNs = 0;
}
SimulatorPrivate::~SimulatorPrivate ()
@ -112,7 +112,7 @@ void
SimulatorPrivate::enable_log_to (char const *filename)
{
m_log.open (filename);
m_log_enable = true;
m_logEnable = true;
}
void
@ -122,9 +122,9 @@ SimulatorPrivate::process_one_event (void)
Scheduler::EventKey next_key = m_events->peek_next_key ();
m_events->remove_next ();
TRACE ("handle " << next_ev);
m_current_ns = next_key.m_ns;
m_current_uid = next_key.m_uid;
if (m_log_enable) {
m_currentNs = next_key.m_ns;
m_currentUid = next_key.m_uid;
if (m_logEnable) {
m_log << "e "<<next_key.m_uid << " " << next_key.m_ns << std::endl;
}
next_ev->invoke ();
@ -149,7 +149,7 @@ void
SimulatorPrivate::run (void)
{
while (!m_events->is_empty () && !m_stop &&
(m_stop_at == 0 || m_stop_at > next ().ns ())) {
(m_stopAt == 0 || m_stopAt > next ().ns ())) {
process_one_event ();
}
m_log.close ();
@ -164,15 +164,15 @@ SimulatorPrivate::stop (void)
void
SimulatorPrivate::stop_at (Time at)
{
m_stop_at = at.ns ();
m_stopAt = at.ns ();
}
EventId
SimulatorPrivate::schedule (Time time, EventImpl *event)
{
if (time.is_destroy ()) {
m_destroy.push_back (std::make_pair (event, m_uid));
if (m_log_enable) {
m_log << "id " << m_current_uid << " " << now ().ns () << " "
if (m_logEnable) {
m_log << "id " << m_currentUid << " " << now ().ns () << " "
<< m_uid << std::endl;
}
m_uid++;
@ -181,8 +181,8 @@ SimulatorPrivate::schedule (Time time, EventImpl *event)
}
assert (time.ns () >= now ().ns ());
Scheduler::EventKey key = {time.ns (), m_uid};
if (m_log_enable) {
m_log << "i "<<m_current_uid<<" "<<now ().ns ()<<" "
if (m_logEnable) {
m_log << "i "<<m_currentUid<<" "<<now ().ns ()<<" "
<<m_uid<<" "<<time.ns () << std::endl;
}
m_uid++;
@ -191,7 +191,7 @@ SimulatorPrivate::schedule (Time time, EventImpl *event)
Time
SimulatorPrivate::now (void) const
{
return Time::abs_ns (m_current_ns);
return Time::abs_ns (m_currentNs);
}
void
@ -200,8 +200,8 @@ SimulatorPrivate::remove (EventId ev)
Scheduler::EventKey key;
EventImpl *impl = m_events->remove (ev, &key);
delete impl;
if (m_log_enable) {
m_log << "r " << m_current_uid << " " << now ().ns () << " "
if (m_logEnable) {
m_log << "r " << m_currentUid << " " << now ().ns () << " "
<< key.m_uid << " " << key.m_ns << std::endl;
}
}
@ -219,7 +219,7 @@ SimulatorPrivate::is_expired (EventId ev)
{
if (ev.get_event_impl () != 0 &&
ev.get_ns () <= now ().ns () &&
ev.get_uid () < m_current_uid) {
ev.get_uid () < m_currentUid) {
return false;
}
return true;
@ -238,27 +238,27 @@ SimulatorPrivate::is_expired (EventId ev)
namespace ns3 {
SimulatorPrivate *Simulator::m_priv = 0;
Simulator::ListType Simulator::m_list_type = LINKED_LIST;
SchedulerFactory const*Simulator::m_sched_factory = 0;
Simulator::ListType Simulator::m_listType = LINKED_LIST;
SchedulerFactory const*Simulator::m_schedFactory = 0;
void Simulator::set_linked_list (void)
{
m_list_type = LINKED_LIST;
m_listType = LINKED_LIST;
}
void Simulator::set_binary_heap (void)
{
m_list_type = BINARY_HEAP;
m_listType = BINARY_HEAP;
}
void Simulator::set_std_map (void)
{
m_list_type = STD_MAP;
m_listType = STD_MAP;
}
void
Simulator::set_external (SchedulerFactory const*factory)
{
assert (factory != 0);
m_sched_factory = factory;
m_list_type = EXTERNAL;
m_schedFactory = factory;
m_listType = EXTERNAL;
}
void Simulator::enable_log_to (char const *filename)
{
@ -271,7 +271,7 @@ Simulator::get_priv (void)
{
if (m_priv == 0) {
Scheduler *events;
switch (m_list_type) {
switch (m_listType) {
case LINKED_LIST:
events = new SchedulerList ();
break;
@ -282,7 +282,7 @@ Simulator::get_priv (void)
events = new SchedulerMap ();
break;
case EXTERNAL:
events = m_sched_factory->create ();
events = m_schedFactory->create ();
default: // not reached
events = 0;
assert (false);
@ -382,7 +382,7 @@ private:
bool m_a;
bool m_c;
bool m_d;
EventId m_id_c;
EventId m_idC;
};
SimulatorTests::SimulatorTests ()
@ -403,7 +403,7 @@ SimulatorTests::b (int b)
} else {
m_b = true;
}
Simulator::remove (m_id_c);
Simulator::remove (m_idC);
Simulator::schedule (Time::rel_us (10), &SimulatorTests::d, this, 4);
}
void
@ -430,7 +430,7 @@ SimulatorTests::run_tests (void)
m_d = false;
EventId a = Simulator::schedule (Time::abs_us (10), &SimulatorTests::a, this, 1);
EventId b = Simulator::schedule (Time::abs_us (11), &SimulatorTests::b, this, 2);
m_id_c = Simulator::schedule (Time::abs_us (12), &SimulatorTests::c, this, 3);
m_idC = Simulator::schedule (Time::abs_us (12), &SimulatorTests::c, this, 3);
Simulator::cancel (a);
Simulator::run ();

4
src/simulator/simulator.h
Unescape View File

@ -480,13 +480,13 @@ private:
static SimulatorPrivate *get_priv (void);
static EventId schedule (Time time, EventImpl *event);
static SimulatorPrivate *m_priv;
static SchedulerFactory const*m_sched_factory;
static SchedulerFactory const*m_schedFactory;
static enum ListType {
LINKED_LIST,
BINARY_HEAP,
STD_MAP,
EXTERNAL
} m_list_type;
} m_listType;
};
}; // namespace ns3

10
src/simulator/time.cc
Unescape View File

@ -25,22 +25,22 @@ namespace ns3 {
Time::Time ()
: m_ns (0),
m_is_destroy (true)
m_isDestroy (true)
{}
Time::Time (Time const &o)
: m_ns (o.m_ns),
m_is_destroy (o.m_is_destroy)
m_isDestroy (o.m_isDestroy)
{}
Time &
Time::operator = (Time const &o)
{
m_ns = o.m_ns;
m_is_destroy = o.m_is_destroy;
m_isDestroy = o.m_isDestroy;
return *this;
}
Time::Time (uint64_t ns)
: m_ns (ns),
m_is_destroy (false)
m_isDestroy (false)
{}
double
@ -66,7 +66,7 @@ Time::ns (void) const
bool
Time::is_destroy (void) const
{
return m_is_destroy;
return m_isDestroy;
}
Time

2
src/simulator/time.h
Unescape View File

@ -46,7 +46,7 @@ protected:
Time ();
private:
uint64_t m_ns;
bool m_is_destroy;
bool m_isDestroy;
};

32
utils/replay-simulation.cc
Unescape View File

@ -48,15 +48,15 @@ private:
union {
struct {
// time at which the event is supposed to expire
uint64_t m_ev_us;
uint64_t m_evUs;
} insert;
struct {
// location in the array of events to remove where
// to insert this event once it is inserted in
// the scheduler.
uint32_t m_ev_loc;
uint32_t m_evLoc;
// time at which the event is supposed to expire
uint64_t m_ev_us;
uint64_t m_evUs;
} insert_remove;
};
};
@ -69,7 +69,7 @@ private:
Commands m_commands;
CommandsI m_command;
RemoveEvents m_remove_events;
RemoveEvents m_removeEvents;
uint32_t m_uid;
};
@ -93,7 +93,7 @@ LogReader::read_from_filename (char const *filename)
struct Command cmd;
cmd.m_type = Command::INSERT;
cmd.m_uid = now_uid;
cmd.insert.m_ev_us = ev_us;
cmd.insert.m_evUs = ev_us;
m_commands.push_back (cmd);
} else if (type == "r") {
uint32_t now_uid, ev_uid;
@ -122,12 +122,12 @@ LogReader::read_from_filename (char const *filename)
for (RemovesI j = removes.begin (); j != removes.end (); j++) {
if (j->second == i->m_uid) {
// this insert will be removed later.
uint64_t us = i->insert.m_ev_us;
uint64_t us = i->insert.m_evUs;
uint32_t uid = i->m_uid;
i->m_type = Command::INSERT_REMOVE;
i->m_uid = uid;
i->insert_remove.m_ev_us = us;
i->insert_remove.m_ev_loc = j->first;
i->insert_remove.m_evUs = us;
i->insert_remove.m_evLoc = j->first;
break;
}
}
@ -140,8 +140,8 @@ LogReader::read_from_filename (char const *filename)
uint32_t loc = 0;
for (CommandsI tmp = i; tmp != m_commands.end (); tmp++) {
if (tmp->m_type == Command::REMOVE &&
tmp->m_uid == i->insert_remove.m_ev_loc) {
i->insert_remove.m_ev_loc = loc;
tmp->m_uid == i->insert_remove.m_evLoc) {
i->insert_remove.m_evLoc = loc;
break;
}
loc++;
@ -163,8 +163,8 @@ LogReader::execute_log_commands (uint32_t uid)
switch (cmd.m_type) {
case Command::INSERT:
//std::cout << "exec insert now=" << Simulator::now_us ()
//<< ", time=" << cmd.insert.m_ev_us << std::endl;
Simulator::schedule_abs_us (cmd.insert.m_ev_us,
//<< ", time=" << cmd.insert.m_evUs << std::endl;
Simulator::schedule_abs_us (cmd.insert.m_evUs,
make_event (&LogReader::execute_log_commands, this, m_uid));
m_uid++;
break;
@ -175,15 +175,15 @@ LogReader::execute_log_commands (uint32_t uid)
break;
case Command::REMOVE: {
//std::cout << "exec remove" << std::endl;
Event ev = m_remove_events.front ();
m_remove_events.pop_front ();
Event ev = m_removeEvents.front ();
m_removeEvents.pop_front ();
Simulator::remove (ev);
} break;
case Command::INSERT_REMOVE: {
//std::cout << "exec insert remove" << std::endl;
Event ev = make_event (&LogReader::execute_log_commands, this, m_uid);
Simulator::schedule_abs_us (cmd.insert_remove.m_ev_us, ev);
m_remove_events[cmd.insert_remove.m_ev_loc] = ev;
Simulator::schedule_abs_us (cmd.insert_remove.m_evUs, ev);
m_removeEvents[cmd.insert_remove.m_evLoc] = ev;
m_uid++;
} break;
}

Write Preview
Loading…
Cancel
Save