F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

member variables coding style change

Browse Source
This commit is contained in:
Mathieu Lacage
2006-09-05 12:54:53 +02:00
parent 2329966acc
commit 778ca40af3
21 changed files with 261 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
samples/main-packet.cc
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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;
}