matteo/sgpemv2
matteo
/
sgpemv2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- Completed code for visualization of the simulation, there`s still the part for the visualization of the request queue commented 

git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@800 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
elvez 2006-07-29 15:48:24 +00:00
parent d64051279f
commit 8b20c7d30a
1 changed files with 101 additions and 592 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

693
src/text_simulation.cc
View File

@ -419,59 +419,6 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
parameters.set_int(p.get_name(), cmd_p.value); parameters.set_int(p.get_name(), cmd_p.value);
++it; ++it;
// ostringstream buf;
//
// buf << "\n";
//
// if(p.is_required())
// buf << "*";
//
// buf << p.get_name() << " (range: [" << p.get_lower_bound() << ", " <<
// p.get_upper_bound() << "] default: " << p.get_default() << ") = ";
//
// p_stdout(buf.str());
//
// bool correct = true;
//
// ustring input = readline();
//
// int value;
//
// // FIXME semi-hack, it's a bit overkill to tokenize the string
// // to find if it's only composed of white spaces...
// // Indedeed there's a pro: by using extensively tokenize() we are more sure
// // it's correct ;-)
// if(tokenize(input).size() > 0)
// {
// try
// {
// value = string_to<int>(input);
//
// if(value > p.get_upper_bound() || value < p.get_lower_bound())
// {
// p_stderr(_("\nERROR: Provided value is out of range"));
// correct = false;
// }
// }
// catch(domain_error e)
// {
// p_stderr(_("\nERROR: Please provide a valid integer value"));
// correct = false;
// }
//
// if(correct)
// parameters.set_int(p.get_name(), value);
// }
// else if(p.is_required())
// {
// p_stderr(_("\nERROR: This is a mandatory attribute; you MUST provide a valid value!"));
//
// correct = false;
// }
//
// if(correct)
// ++it;
} }
p_stdout(_("\nFloating-point arguments:\n")); p_stdout(_("\nFloating-point arguments:\n"));
@ -494,58 +441,6 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
parameters.set_float(p.get_name(), cmd_p.value); parameters.set_float(p.get_name(), cmd_p.value);
++it; ++it;
// ostringstream buf;
//
// buf << "\n";
//
// if(p.is_required())
// buf << "*";
//
// buf << p.get_name() << " (range: [" << p.get_lower_bound() << ", " <<
// p.get_upper_bound() << "] default: " << p.get_default() << ") = ";
//
// p_stdout(buf.str());
//
// bool correct = true;
//
// ustring input = readline();
//
// float value;
//
// // FIXME semi-hack, it's a bit overkill to tokenize the string
// // to find if it's only composed of white spaces...
// // Indedeed there's a pro: by using extensively tokenize() we are more sure
// // it's correct ;-)
// if(tokenize(input).size() > 0)
// {
// try
// {
// value = string_to<float>(input);
//
// if(value > p.get_upper_bound() || value < p.get_lower_bound())
// {
// p_stderr(_("\nERROR: Provided value is out of range"));
// correct = false;
// }
// }
// catch(domain_error e)
// {
// p_stderr(_("\nERROR: Please provide a valid floating-point value"));
// correct = false;
// }
//
// if(correct)
// parameters.set_float(p.get_name(), value);
// }
// else if(p.is_required())
// {
// p_stderr(_("\nERROR: This is a mandatory attribute; you MUST provide a valid value!"));
//
// correct = false;
// }
//
// if(correct)
// ++it;
} }
p_stdout(_("\nString arguments:\n")); p_stdout(_("\nString arguments:\n"));
@ -563,32 +458,6 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
parameters.set_string(p.get_name(), cmd_p.value); parameters.set_string(p.get_name(), cmd_p.value);
++it; ++it;
// ustring buf;
//
// buf = "\n";
//
// if(p.is_required())
// buf += "*";
//
// p_stdout(buf + p.get_name() + " = ");
//
// buf = readline();
//
// // FIXME semi-hack, it's a bit overkill to tokenize the string
// // to find if it's only composed of white spaces...
// // Indedeed there's a pro: by using extensively tokenize() we are more sure
// // it's correct ;-)
// Tokens tokens = tokenize(buf);
//
// if(tokens.size() == 0 && p.is_required())
// p_stderr(_("\nERROR: This is a mandatory atribute; you MUST provide a valid value!"));
// else
// {
// // FIXME should we insert the entire line here or just a token?
// parameters.set_string(p.get_name(), buf);
// ++it;
// }
} }
} }
@ -1436,397 +1305,66 @@ TextSimulation::parse_command(TextSimulation& sim, const ustring& str)
(sim.*(command_handlers[key]))(arguments); (sim.*(command_handlers[key]))(arguments);
} }
// ** Please do NOT delete this code, I still use it as a reference ** static ostream&
//void operator<<(ostream& os, Schedulable::state state)
//TextSimulation::parse_command(pair< pair<TextSimulation*, IOManager*>, const ustring > p) {
//{ switch(state)
// {
// TextSimulation* obj = p.first.first; case Schedulable::state_running:
// ustring str = p.second; os << "RUNNING";
// //looks for the IOManager who sent the command break;
// uint quale = 0; case Schedulable::state_ready:
// for (; quale < obj->_devices.size(); quale++) os << "READY";
// if (p.first.second == &(*obj->_devices[quale])) break;
// break; case Schedulable::state_blocked:
// os << "BLOCKED";
// if (str.length() == 0) break;
// return; case Schedulable::state_future:
// os << "FUTURE";
// //CAPITALIZE alla grguments break;
// str = str.uppercase(); case Schedulable::state_terminated:
// os << "TERMINATED";
// vector<ustring> arguments; break;
// uint f = 0; default:
// static const ustring whitespaces = " \r\b\n\t\a"; os.setstate(ios_base::failbit);
// //fills the vector with parameters }
// while (true)
// {
// f = str.find_first_of(whitespaces);
// if (f > str.length())
// {
// //the end of the string
// arguments.push_back(str);
// break;
// }
// else
// {
// //add the token
// arguments.push_back(str.substr(0, f));
// //trim the initial whitespaces
// str = str.substr(f + 1);
// f = str.find_first_not_of(whitespaces);
// str = str.substr(f);
// }
// }
//
// if (arguments.size() == 0)
// return;
//
// bool show_help = false;
// int param = 0;
//check:
//
// if (arguments[param] == "RUN")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- RUN COMMAND --\nStarts the simulation. It can be continuous or step-by-step"
// " depending on the mode configured with SetMode (default=continuous).\n\n"
// "The output of RUN is one or more rows each of which represents the state of the "
// "schedulable entities. It can be RUNNING, READY, BLOCKED, FUTURE or TERMINATED."
// "\nThe row begins with the number of the instant described by the following lists of states. "
// "The instant 0 represents the INITIAL STATE during which no process is running. The scheduler "
// "activity begins at instant 1. Each schedulable entity is represented by its name followed "
// "by its priority enclosed between round parenthesis."));
// return;
// }
//
// try
// {
// obj->run();
// }
// catch(UserInterruptException e)
// {
// obj->_devices[quale]->write_buffer(_("\nERROR: "));
// obj->_devices[quale]->write_buffer(_(e.what()));
// obj->_devices[quale]->write_buffer(_("\nSimulation is now stopped"));
//
// }
// }
// else if (arguments[param] == "PAUSE")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- PAUSE COMMAND --\nPauses the simulation. The next call to RUN will restart it."));
// return;
// }
// obj->pause();
// }
// else if (arguments[param] == "STOP")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- STOP COMMAND --\nStops the simulation. The next call to RUN will "
// "bring the simulation to the FIRST instant and start it."));
// return;
// }
// obj->stop();
// }
// else if (arguments[param] == "RESET")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- RESET COMMAND --\nResets the simulation jumping back to the first instant."));
// return;
// }
// obj->reset();
// }
// else if (arguments[param] == "QUIT")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- QUIT COMMAND --\nExits the program."));
// return;
// }
// obj->_devices[quale]->write_buffer(_("\n\n*** Thank you for using SGPEM by Sirius Cybernetics Corporation ***\n\n"));
// exit(1);
// }
// else if (arguments[param] == "HELP")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- Do you really want me to explain what HELP means? --"
// "\n ************** YOU ARE JOKING ME !!! ************\n\n"));
// exit(1);
// }
// if (arguments.size() == 1)
// {
// obj->_devices[quale]->write_buffer( "\nAvaiable commands:\nRUN\nPAUSE\nSTOP\nRESET\nQUIT\nHELP"
// "\nGETMODE\nSETMODE\nSETTIMER\nGETTIMER\nJUMPTO\nGETPOLICY"
// "\nSETPOLICY\nGETPOLICYATTRIBUTES"
// "\n\nHELP followed by a command shows help about it."
// "\n ex. HELP RUN shows help about the command RUN");
// return;
// }
// show_help = true;
// param = 1;
// goto check;
// }
// else if (arguments[param] == "SETMODE")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- SetMode COMMAND --\nPermits to change the mode of the simulation.\n\nSintax: Setmode <param>\n\t<param> can take values:\n"
// "\n\t\tCONTINUOUS - when calling RUN the simulation will show an animation using the wait-interval set by SETTIMER\n"
// "\n\t\tSTEP - when calling RUN the simulation will show only one step of the animation\n"));
// return;
// }
// if (arguments.size() != 2)
// {
// obj->_devices[quale]->write_buffer(_("\nERROR: wrong number of parameters."
// "\nType HELP SETMODE for the description of the sintax"));
// return;
// }
// if (arguments[1] == "CONTINUOUS")
// obj->set_mode(true);
// else if (arguments[1] == "STEP")
// obj->set_mode(false);
// else
// obj->_devices[quale]->write_buffer(_("\nERROR: the second parameter can be only CONTINUOUS or STEP"));
//
// }
// else if (arguments[param] == "GETMODE")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- GetMode COMMAND --\nReturns\n\tCONTINUOUS : if the simulation is shown with an animation"
// "\n\tSTEP : if if the simulation is shown step-by-step"));
// return;
// }
// if (obj->get_mode())
// obj->_devices[quale]->write_buffer(_("\nCONTINUOUS"));
// else
// obj->_devices[quale]->write_buffer(_("\nSTEP"));
// }
// else if (arguments[param] == "SETTIMER")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- SetTimer COMMAND --\nPermits to change the interval between a step and the following one during a continuous animation."
// "\n\nSintax: SetTimer <param>\n\t<param> must be an integer value > 0 and < 10000.\n"));
// return;
// }
// if (arguments.size() != 2)
// {
// obj->_devices[quale]->write_buffer(_("\nERROR: wrong number of parameters."
// "\nType HELP SETTIMER for the description of the sintax"));
// return;
// }
// int num;
// if (string_to_int(arguments[1], num) && num > 0 && num < 10000)
// obj->set_timer(num);
// else
// obj->_devices[quale]->write_buffer(_(
// "\nERROR: the second parameter has a wrong value."
// "\nType HELP SETTIMER for the description of the sintax"));
// }
// else if (arguments[param] == "GETTIMER")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- GetTimer COMMAND --\nReturns the number of milliseconds the simulation "
// "in the continuous mode waits between a step and the following one"));
// return;
// }
// ustring ss;
// int_to_string(obj->get_timer(), ss);
// obj->_devices[quale]->write_buffer(ss);
// }
// else if (arguments[param] == "JUMPTO")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- JumpTo COMMAND --\nPermits to jump to a desired instant of the simulation."
// " All states of the simulation before <param> will be recalculated and printed out."
// "\n\nSintax: JumpTo <param>\n\t<param> must be an integer value >= 0"));
// return;
// }
// if (arguments.size() != 2)
// {
// obj->_devices[quale]->write_buffer(_("\nERROR: wrong number of parameters."
// "\nType HELP JUMPTO for the description of the sintax"));
// return;
// }
// int num;
// if (string_to_int(arguments[1], num) && num >= 0)
// obj->jump_to(num);
// else
// obj->_devices[quale]->write_buffer(_(
// "\nERROR: the second parameter has a wrong value."
// "\nType HELP JUMPTO for the description of the sintax"));
// }
// else if (arguments[param] == "GETPOLICY")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- GetPolicy COMMAND --\nReturns the name and the description of the current applied policy."));
// return;
// }
// obj->_devices[quale]->write_buffer(obj->get_policy()->get_description());
// }
// else if(arguments[param] == "SETPOLICY")
// {
// if(show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- SetPolicy COMMAND --\nSelects the current applied policy."
// "Syntax: SetPolicy <name>"));
// return;
// }
//
//
// //FIXME assuming only one policy manager is present, but who cares, this
// //is only temporary code...
// PolicyManager* manager = PoliciesGatekeeper::get_instance().get_registered()[0];
//
// vector<Policy*> available = manager->get_avail_policies();
//
//
// obj->_devices[quale]->write_buffer(arguments[1] + "\n");
//
// for(vector<Policy*>::iterator it = available.begin(); it != available.end(); ++it)
// {
// if((*it)->get_name().casefold() == arguments[1].casefold())
// {
// obj->stop();
// PoliciesGatekeeper::get_instance().activate_policy(&History::get_instance(), *it);
// return;
// }
// }
//
//
// obj->_devices[quale]->write_buffer(_(
// "\nERROR: no policy found with that name."
// "\nType HELP SETPOLICY for the description of the sintax"));
//
// }
// else if(arguments[param] == "LISTPOLICIES")
// {
// if(show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- ListPolicies COMMAND --\nShows the name of available policies."));
// return;
// }
//
// //FIXME assuming only one policy manager is present, but who cares, this
// //is only temporary code...
// PolicyManager* manager = PoliciesGatekeeper::get_instance().get_registered()[0];
//
// vector<Policy*> available = manager->get_avail_policies();
//
// for(vector<Policy*>::iterator it = available.begin(); it != available.end(); ++it)
// {
//
//// Glib::ustring str;
//// int_to_string((int)*it, str);
//// obj->_devices[quale]->write_buffer(str + "\n");
// obj->_devices[quale]->write_buffer("\n" + (*it)->get_name());
// }
// }
// else if (arguments[param] == "GETPOLICYATTRIBUTES")
// {
// if (show_help)
// {
// obj->_devices[quale]->write_buffer(_(
// "\n-- GetPolicyAttributes COMMAND --\nReturns the list of attributes of the current applied policy."
// "\nThe description of each parameter includes:"
// "\n\tthe NAME of the marameter with its type\n\tits current VALUE"
// "\n\tits LOWER and UPPER bounds\n\twhether the parameter is REQUIRED"));
// return;
// }
//
// ustring temp;
//
// const PolicyParameters& param = obj->get_policy()->get_parameters();
// map<ustring, PolicyParameters::Parameter<int> > map_i = param.get_registered_int_parameters();
// map<ustring, PolicyParameters::Parameter<int> >::iterator i_i = map_i.begin();
//
// for(; i_i != map_i.end(); i_i++)
// {
// obj->_devices[quale]->write_buffer("\nint\t" + i_i->second.get_name());
// int_to_string(i_i->second.get_value(), temp);
// obj->_devices[quale]->write_buffer("\tvalue=" + temp);
// int_to_string(i_i->second.get_lower_bound(), temp);
// obj->_devices[quale]->write_buffer("\t\tlower=" + temp);
// int_to_string(i_i->second.get_upper_bound(), temp);
// obj->_devices[quale]->write_buffer("\t\tupper=" + temp);
// if (i_i->second.is_required())
// obj->_devices[quale]->write_buffer("\t\trequired=true");
// else
// obj->_devices[quale]->write_buffer("\t\trequired=false");
// }
//
// map<ustring, PolicyParameters::Parameter<float> > map_f = param.get_registered_float_parameters();
// map<ustring, PolicyParameters::Parameter<float> >::iterator i_f = map_f.begin();
//
// for(; i_f != map_f.end(); i_f++)
// {
// obj->_devices[quale]->write_buffer("\nfloat\t" + i_f->second.get_name());
// float_to_string(i_f->second.get_value(), temp);
// obj->_devices[quale]->write_buffer("\tvalue=" + temp);
// float_to_string(i_f->second.get_lower_bound(), temp);
// obj->_devices[quale]->write_buffer("\t\tlower=" + temp);
// float_to_string(i_f->second.get_upper_bound(), temp);
// obj->_devices[quale]->write_buffer("\t\tupper=" + temp);
// if (i_f->second.is_required())
// obj->_devices[quale]->write_buffer("\t\trequired=true");
// else
// obj->_devices[quale]->write_buffer("\t\trequired=false");
// }
//
// map<ustring, PolicyParameters::Parameter<ustring> > map_s = param.get_registered_string_parameters();
// map<ustring, PolicyParameters::Parameter<ustring> >::iterator i_s = map_s.begin();
//
// for(; i_s != map_s.end(); i_s++)
// {
// obj->_devices[quale]->write_buffer("\nustring\t" + i_s->second.get_name());
// obj->_devices[quale]->write_buffer("\tvalue=" + i_s->second.get_value());
// if (i_s->second.is_required())
// obj->_devices[quale]->write_buffer(" required=true");
// else
// obj->_devices[quale]->write_buffer(" required=false");
// }
//
// }
// else
// {
// obj->_devices[quale]->write_buffer(_("\nCommand not recognized: "));
// obj->_devices[quale]->write_buffer(arguments[param]);
// obj->_devices[quale]->write_buffer(_("\nTyper HELP for a list of avaiable commands."));
// return;
// }
//}
return os;
}
static ostream&
operator<<(ostream& os, Request::state state)
{
switch(state)
{
case Request::state_unallocable:
os << "UNALLOCABLE";
break;
case Request::state_allocated:
os << "ALLOCATED";
break;
case Request::state_future:
os << "FUTURE";
break;
case Request::state_exhausted:
os << "EXHAUSTED";
break;
case Request::state_allocable:
os << "ALLOCABLE";
break;
default:
os.setstate(ios_base::failbit);
}
return os;
}
void void
TextSimulation::update(const History& changed_history) TextSimulation::update(const History& changed_history)
{ {
ostringstream oss; ostringstream oss;
oss << changed_history.get_size() - 1 << _(".\tready queue: { "); oss << ">>>> " << changed_history.get_size() - 1 << _("\nREADY QUEUE: { ");
p_stdout(oss.str()); p_stdout(oss.str());
@ -1844,7 +1382,7 @@ TextSimulation::update(const History& changed_history)
p_stdout("}\n"); p_stdout("}\n");
p_stdout(_("\tresources:\n")); p_stdout(_("RESOURCES:\n"));
const Environment::Resources& resources = env.get_resources(); const Environment::Resources& resources = env.get_resources();
typedef Environment::Resources::const_iterator ResourceIt; typedef Environment::Resources::const_iterator ResourceIt;
@ -1854,7 +1392,7 @@ TextSimulation::update(const History& changed_history)
const Resource& r = *it->second; const Resource& r = *it->second;
Environment::resource_key_t key = it->first; Environment::resource_key_t key = it->first;
oss << "\t\t" << key << ". " << r.get_name() << _(", with "); oss << " " << key << ") " << r.get_name() << _(", with ");
oss << r.get_places() << _(" places\n"); oss << r.get_places() << _(" places\n");
@ -1878,7 +1416,7 @@ TextSimulation::update(const History& changed_history)
// p_stdout("}\n"); // p_stdout("}\n");
} }
p_stdout(_("\tprocesses:\n")); p_stdout(_("PROCESSES:\n"));
const Environment::Processes& processes = env.get_processes(); const Environment::Processes& processes = env.get_processes();
@ -1886,88 +1424,59 @@ TextSimulation::update(const History& changed_history)
{ {
Process& p = *processes[pi]; Process& p = *processes[pi];
oss << "\t\t" << pi + 1 << ". " << p.get_name() << " "; oss << " " << pi + 1 << ") " << p.get_name() << " ";
oss << "[" << p.get_state() << "] "; oss << "[" << p.get_state() << "] ";
oss << _("arriving at ") << p.get_arrival_time() << " "; oss << _("arriving at ") << p.get_arrival_time() << ", ";
oss << _("requiring ") << p.get_total_cpu_time() << " "; oss << _("requiring ") << p.get_total_cpu_time() << ", ";
oss << _("elapsed ") << p.get_elapsed_time() << " "; oss << _("elapsed ") << p.get_elapsed_time() << ", ";
oss << _("priority ") << p.get_current_priority() << endl; oss << _("priority ") << p.get_current_priority() << endl;
p_stdout(oss.str()); p_stdout(oss.str());
oss.str(string()); oss.str(string());
vector<Thread*> threads = p.get_threads();
for(unsigned int ti = 0; ti < threads.size(); ++ti)
{
Thread& t = *threads[ti];
oss << " " << ti + 1 << ") " << t.get_name() << " ";
oss << "[" << t.get_state() << "] ";
oss << _("arriving at ") << t.get_arrival_time() << ", ";
oss << _("requiring ") << t.get_total_cpu_time() << ", ";
oss << _("elapsed ") << t.get_elapsed_time() << ", ";
oss << _("priority ") << t.get_current_priority() << endl;
p_stdout(oss.str());
oss.str(string());
vector<Request*> requests = t.get_requests();
for(unsigned int ri = 0; ri < requests.size(); ++ri)
{
Request& r = *requests[ri];
vector<SubRequest*> subrequests = r.get_subrequests();
for(unsigned int sri = 0; sri < subrequests.size(); ++sri)
{
SubRequest& sr = *subrequests[sri];
oss << _(" --> request ") << ri + 1 << "." << sri + 1 << ") ";
oss << _("at ") << r.get_instant() << " ";
oss << _("for resource ") << sr.get_resource_key() << " ";
oss << "[" << sr.get_state() << "] ";
oss << _("requiring ") << sr.get_length() << ", ";
oss << _("remaining ") << sr.get_remaining_time() << endl;
p_stdout(oss.str());
oss.str(string());
}
}
}
} }
p_stdout("\n"); p_stdout("\n");
// History& h = History::get_instance();
// int when, arr;
// ustring temp;
//
// when = h.get_current_time();
// smart_ptr<ReadyQueue> ll = h.get_simulation_status_at(when);
//
// for (uint dev = 0; dev < _devices.size(); dev++)
// {
// int_to_string(when, temp);
// if (when < 10)
// _devices[dev]->write_buffer("\n ");
// else
// _devices[dev]->write_buffer("\n");
// _devices[dev]->write_buffer(temp + ") [RUNS]");
//
// //insert the RUNNING ONE
// smart_ptr<DynamicSchedulable> running = h.get_scheduled_at(when);
// if (running)
// {
// arr = running->get_schedulable()->get_arrival_time();
// int_to_string(arr, temp);
// _devices[dev]->write_buffer(" " + running->get_schedulable()->get_name() + "_(" + temp + ")");
// }
//
// _devices[dev]->write_buffer(" --[READY]");
// //insert the READY ones
// for (uint i = 0; i < ll->size(); i++)
// if (ll->get_item_at(i)->get_state() == DynamicSchedulable::state_ready)
// {
// arr = ll->get_item_at(i)->get_schedulable()->get_arrival_time();
// int_to_string(arr, temp);
// _devices[dev]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
// }
//
// _devices[dev]->write_buffer(" --[BLOCKED]");
// //insert the BLOCKED ones
// for (uint i = 0; i < ll->size(); i++)
// if (ll->get_item_at(i)->get_state() == DynamicSchedulable::state_blocked)
// {
// arr = ll->get_item_at(i)->get_schedulable()->get_arrival_time();
// int_to_string(arr, temp);
// _devices[dev]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
// }
//
// _devices[dev]->write_buffer(" --[FUTURE]");
// //insert the FUTURE ones
// for (uint i = 0; i < ll->size(); i++)
// if (ll->get_item_at(i)->get_state() == DynamicSchedulable::state_future)
// {
// arr = ll->get_item_at(i)->get_schedulable()->get_arrival_time();
// int_to_string(arr, temp);
// _devices[dev]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
// }
//
// _devices[dev]->write_buffer(" --[TERM]");
// //insert the TERMINATED ones
// for (uint i = 0; i < ll->size(); i++)
// if (ll->get_item_at(i)->get_state() == DynamicSchedulable::state_terminated)
// {
// arr = ll->get_item_at(i)->get_schedulable()->get_arrival_time();
// int_to_string(arr, temp);
// _devices[dev]->write_buffer(" " + ll->get_item_at(i)->get_schedulable()->get_name() + "_(" + temp + ")");
// }
//
// }
} }
void void