/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
* Copyright (c) 2006 INRIA
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include "yans/simulator.h"
#include "yans/event.h"
#include "yans/event.tcc"
#include "yans/wall-clock-ms.h"
#include <vector>
#include <deque>
#include <fstream>
#include <iostream>
using namespace yans;
class LogReader {
public:
void read_from_filename (char const *filename);
void run (void);
void print_stats (void);
private:
struct Command {
enum {
REMOVE,
INSERT,
INSERT_LATER,
INSERT_REMOVE
} m_type;
// uid at which this command is supposed to be executed.
uint32_t m_uid;
union {
struct {
// time at which the event is supposed to expire
uint64_t m_ev_us;
} 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;
// time at which the event is supposed to expire
uint64_t m_ev_us;
} insert_remove;
};
};
void execute_log_commands (uint32_t uid);
typedef std::deque<struct Command> Commands;
typedef std::deque<struct Command>::iterator CommandsI;
typedef std::deque<Event > RemoveEvents;
Commands m_commands;
CommandsI m_command;
RemoveEvents m_remove_events;
uint32_t m_uid;
};
typedef std::vector<std::pair<uint32_t, uint32_t> > Removes;
typedef std::vector<std::pair<uint32_t, uint32_t> >::iterator RemovesI;
void
LogReader::read_from_filename (char const *filename)
{
std::ifstream log;
std::cout << "read log..." << std::endl;
Removes removes;
log.open (filename);
while (!log.eof ()) {
std::string type;
log >> type;
if (type == "i") {
uint32_t now_uid, ev_uid;
uint64_t now_us, ev_us;
log >> now_uid >> now_us >> ev_uid >> ev_us;
struct Command cmd;
cmd.m_type = Command::INSERT;
cmd.m_uid = now_uid;
cmd.insert.m_ev_us = ev_us;
m_commands.push_back (cmd);
} else if (type == "r") {
uint32_t now_uid, ev_uid;
uint64_t now_us, ev_us;
log >> now_uid >> now_us >> ev_uid >> ev_us;
struct Command cmd;
cmd.m_type = Command::REMOVE;
cmd.m_uid = now_uid;
m_commands.push_back (cmd);
removes.push_back (std::make_pair (now_uid, ev_uid));
} else if (type == "il") {
uint32_t now_uid, ev_uid;
uint64_t now_us, ev_us;
log >> now_uid >> now_us >> ev_uid >> ev_us;
struct Command cmd;
cmd.m_type = Command::INSERT_LATER;
cmd.m_uid = now_uid;
m_commands.push_back (cmd);
}
}
log.close ();
std::cout << "gather insert removes..." << std::endl;
for (CommandsI i = m_commands.begin (); i != m_commands.end (); i++) {
if (i->m_type == Command::INSERT) {
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;
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;
break;
}
}
}
}
std::cout << "calculate remove locations..." << std::endl;
// calculate the final insert/remove location.
for (CommandsI i = m_commands.begin (); i != m_commands.end (); i++) {
if (i->m_type == Command::INSERT_REMOVE) {
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;
break;
}
loc++;
}
}
}
}
void
LogReader::execute_log_commands (uint32_t uid)
{
if (m_command == m_commands.end ()) {
return;
}
//std::cout << "one event, uid=" <<m_uid<< std::endl;
struct Command cmd = *m_command;
//std::cout << "cmd uid=" <<cmd.m_uid<< std::endl;
while (cmd.m_uid == uid) {
m_command++;
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,
make_event (&LogReader::execute_log_commands, this, m_uid));
m_uid++;
break;
case Command::INSERT_LATER:
//std::cout << "exec insert later" << std::endl;
Simulator::schedule_now (make_event (&LogReader::execute_log_commands, this, m_uid));
m_uid++;
break;
case Command::REMOVE: {
//std::cout << "exec remove" << std::endl;
Event ev = m_remove_events.front ();
m_remove_events.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;
m_uid++;
} break;
}
cmd = *m_command;
}
}
void
LogReader::print_stats (void)
{
uint32_t n_inserts = 0;
uint32_t n_removes = 0;
for (CommandsI i = m_commands.begin (); i != m_commands.end (); i++) {
switch (i->m_type) {
case Command::INSERT:
n_inserts++;
break;
case Command::INSERT_LATER:
n_inserts++;
break;
case Command::INSERT_REMOVE:
n_inserts++;
break;
case Command::REMOVE:
n_removes++;
break;
}
}
std::cout << "inserts="<<n_inserts<<", removes="<<n_removes<<std::endl;
std::cout << "run simulation..."<<std::endl;
}
void
LogReader::run (void)
{
m_uid = 0;
WallClockMs time;
time.start ();
m_command = m_commands.begin ();
execute_log_commands (m_uid);
Simulator::run ();
unsigned long long delta = time.end ();
double delay = ((double)delta)/1000;
std::cout << "runtime="<<delay<<"s"<<std::endl;
}
int main (int argc, char *argv[])
{
char const *input = 0;
uint32_t n = 1;
while (argc > 0) {
if (strcmp ("--list", argv[0]) == 0) {
Simulator::set_linked_list ();
} else if (strcmp ("--heap", argv[0]) == 0) {
Simulator::set_binary_heap ();
} else if (strcmp ("--map", argv[0]) == 0) {
Simulator::set_std_map ();
} else if (strncmp ("--n=", argv[0], strlen("--n=")) == 0) {
n = atoi (argv[0]+strlen ("--n="));
} else if (strncmp ("--input=", argv[0],strlen ("--input=")) == 0) {
input = argv[0] + strlen ("--input=");
} else if (strncmp ("--log=", argv[0],strlen ("--log=")) == 0) {
char const *filename = argv[0] + strlen ("--log=");
Simulator::enable_log_to (filename);
}
argc--;
argv++;
}
if (input == 0) {
std::cerr << "need --input=[filename] option" << std::endl;
return 1;
}
LogReader log;
log.read_from_filename (input);
for (uint32_t i = 0; i < n; i++) {
log.run ();
}
}