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

- Fixed some bugs in command processing, added the configure-cpu-policy command 

git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@748 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
elvez 2006-07-10 22:28:51 +00:00
parent 1a6805afc4
commit 6150af3d30
8 changed files with 196 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
plugins/pyloader/src/builtin-policies/fcfs.py
View File

@ -21,7 +21,7 @@
from Policy import Policy
import sys
from sgpem import policy_sorts_processes
#from sgpem import policy_sorts_processes
class fcfs(Policy) :
def __init__(self):
@ -36,6 +36,11 @@ class fcfs(Policy) :
def get_time_slice(self):
return -2
# FIXME incorrect, but must be implemented to allow
# loading from the policy manager
def wants(self):
return 0
def sort_queue(self, queue):
cmpf = lambda a, b: \
a.get_arrival_time() < \

7
plugins/pyloader/src/builtin-policies/sjf.py
View File

@ -21,7 +21,7 @@
from Policy import Policy
import sys
from sgpem import policy_sorts_processes
#from sgpem import policy_sorts_processes
class sjf(Policy) :
def __init__(self):
@ -36,6 +36,11 @@ class sjf(Policy) :
def get_time_slice(self):
return -1
# FIXME incorrect, but must be implemented to allow
# loading from the policy manager
def wants(self):
return 0
def sort_queue(self, queue):
cmpf = lambda a, b: \
a.get_remaining_time() < \

19
src/backend/string_utils.cc
View File

@ -72,8 +72,9 @@ string_to_int(const ustring& str, int& num)
return true;
}
int
string_to_int(const ustring& str) throw(domain_error)
template <typename T>
T
string_to(const ustring& str) throw(domain_error)
{
if(tokenize(str).size() != 1)
throw domain_error("too few or too many tokens");
@ -82,17 +83,24 @@ string_to_int(const ustring& str) throw(domain_error)
iss.exceptions(ios_base::failbit | ios_base::badbit);
int value;
T value;
try
{
iss >> value;
}
catch(ios_base::failure& e)
catch(ios_base::failure e)
{
throw domain_error(e.what());
}
// disable exceptions, otherwise peek() will throw them!
// how useless!!!
iss.exceptions(ios_base::goodbit);
if(iss.peek() != istringstream::traits_type::eof())
throw domain_error("incorrect number format");
return value;
}
@ -187,4 +195,7 @@ tokenize(const ustring& str)
return tokens;
}
template int string_to<int>(const Glib::ustring&);
template float string_to<float>(const Glib::ustring&);
}

4
src/backend/string_utils.hh
View File

@ -45,8 +45,8 @@ namespace sgpem
*/
bool SG_DLLEXPORT string_to_int(const Glib::ustring&, int&);
int SG_DLLEXPORT string_to_int(const Glib::ustring&) throw(std::domain_error);
template <typename T>
T SG_DLLEXPORT string_to(const Glib::ustring&) throw(std::domain_error);
/**\brief This function converts an integer value into a string.

3
src/graphical_terminal_io.cc
View File

@ -89,7 +89,8 @@ GraphicalTerminalIO::onSend()
pair<TextSimulation*, IOManager*>(_sim, this),
read_command());
Thread::create(sigc::bind(&TextSimulation::parse_command, p), true);
//No way it will work with a graphical terminal at the moment
//Thread::create(sigc::bind(&TextSimulation::parse_command, p), true);
}
uint

19
src/main.cc
View File

@ -24,6 +24,8 @@
#include "main.hh"
#include "parse_opts.hh"
#include "text_simulation.hh"
#include "io_manager.hh"
#include <glibmm/module.h>
#include <glibmm/thread.h>
@ -52,7 +54,18 @@ main(int argc, char* argv[])
// Parses options and prepares vector with
// filenames of documents to be opened
parse_options(argc, argv);
return 0;
parse_options(argc, argv);
TextSimulation sim;
while(1)
{
string str;
getline(cin, str);
TextSimulation::parse_command(sim, str);
}
return 0;
}

210
src/text_simulation.cc
View File

@ -24,6 +24,7 @@
#include "backend/policy_parameters.hh"
#include "backend/history.hh"
#include "text_simulation.hh"
#include <sstream>
@ -99,17 +100,31 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
{
arguments_ignored(arguments);
PolicyParameters& parameters = get_policy()->get_parameters();
// FIXME we should use the current policy to obtain parmaters, this code
// is only for testing purposes
PolicyParameters parameters;
p_stdout(_("\nPlease provide a value for each attribute"));
p_stdout(_("\nMandatory arguments are marked with an asterisk (*)"));
parameters.register_int("a", -50, 50, false, 10);
parameters.register_int("b", -2, INT_MAX, true);
parameters.register_int("c", INT_MIN, 2, true);
parameters.register_float("d", -FLT_MAX, FLT_MAX, true);
parameters.register_float("e", -5.0f, 50.0f, false, 10);
parameters.register_float("f", -FLT_MAX, 2.0f, true);
parameters.register_string("g", false);
parameters.register_string("h", true);
parameters.register_string("g", true);
p_stdout(_("\nPlease provide a value for each attribute:"));
p_stdout(_("\nMandatory arguments are marked with an asterisk (*)\n"));
p_stdout(_("\nInteger arguments:\n"));
typedef map<ustring, PolicyParameters::Parameter<int> > IntParams;
typedef map<ustring, PolicyParameters::Parameter<float> > FloatParams;
typedef map<ustring, PolicyParameters::Parameter<ustring> > StringParams;
// TODO for int and double this code is easily replaced with a call to a
// template function. for strings we'll need to specialize it...
IntParams int_params = parameters.get_registered_int_parameters();
for(IntParams::iterator it = int_params.begin(); it != int_params.end();)
@ -127,7 +142,6 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
p_stdout(buf.str());
bool arg_provided = false;
bool correct = true;
ustring input = readline();
@ -142,7 +156,13 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
{
try
{
value = string_to_int(input);
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)
{
@ -150,14 +170,8 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
correct = false;
}
if(value > p.get_upper_bound() || value < p.get_lower_bound())
{
p_stderr(_("\nERROR: Provided value is out of range"));
correct = false;
}
if(correct)
p.set_value(value);
parameters.set_int(p.get_name(), value);
}
else if(p.is_required())
{
@ -170,41 +184,109 @@ TextSimulation::on_configure_cpu_policy(const Tokens& arguments)
++it;
}
//FIXME code for float arguments
p_stdout(_("\nFloating-point arguments:\n"));
// NOTE this piece code is a verbatim copy of the one above.
// I tried solving this issue by using templates, but to make
// it work will require adding to PolicyParameters a member template
// method with 2 specializations...
// StringParams string_params = parameters->get_registered_string_parameters();
//
// for(StringParams::iterator it = int_params.begin(); it != int_params.end();)
// {
// Parameter<ustring> &p = *it;
// ustring buf;
//
// buf = "\n";
//
// if(p.is_required())
// buf += "*";
//
// p_stdout(buf + p.get_name() + " = ");
//
// buf = read();
//
// // 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(input);
//
// if(tokens.size() == 0 && p.is_required())
// p_stderr(_("\nERROR: This is a mandatory atribute; you MUST provide a valid value!"));
// else
// {
// p.set_value(tokens[0]);
// ++it;
// }
//
// }
FloatParams float_params = parameters.get_registered_float_parameters();
for(FloatParams::iterator it = float_params.begin(); it != float_params.end();)
{
PolicyParameters::Parameter<float> &p = it->second;
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"));
StringParams string_params = parameters.get_registered_string_parameters();
for(StringParams::iterator it = string_params.begin(); it != string_params.end();)
{
PolicyParameters::Parameter<ustring> &p = it->second;
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;
}
}
}
void
TextSimulation::on_help(const Tokens& arguments)
{
@ -212,7 +294,7 @@ TextSimulation::on_help(const Tokens& arguments)
//make a local copy which we'll probably modify
Tokens args = arguments;
if(args.size() > 1)
if(args.size() > 0)
{
command = args[0].uppercase();
args.erase(args.begin());
@ -222,9 +304,9 @@ TextSimulation::on_help(const Tokens& arguments)
if(command.size() == 0)
p_stdout(_("\nAvaiable commands:\nRUN\nPAUSE\nSTOP\nQUIT\nHELP"
"\nGET\nSET\nSHOW\nADD\nREMOVE"
"\nGET\nSET\nSHOW\nADD\nREMOVE\nCONFIGURE-CPU-POLICY"
"\n\nHELP followed by a command shows help about it."
"\n ex. HELP RUN shows help about the command RUN"));
"\n ex. HELP RUN shows help about the command RUN\n"));
else if(command == "RUN")
p_stdout(_("\n-- RUN COMMAND --\nStarts the simulation. It can be "
"continuous or step-by-step depending on the mode configured with "
@ -278,31 +360,31 @@ TextSimulation::on_quit(const Tokens& arguments)
void
TextSimulation::on_get(const Tokens& arguments)
{
p_stderr(_("\nFIXME: Not implemented"));
p_stderr(_("\nFIXME: Not implemented\n"));
}
void
TextSimulation::on_set(const Tokens& arguments)
{
p_stderr(_("\nFIXME: Not implemented"));
p_stderr(_("\nFIXME: Not implemented\n"));
}
void
TextSimulation::on_show(const Tokens& arguments)
{
p_stderr(_("\nFIXME: Not implemented"));
p_stderr(_("\nFIXME: Not implemented\n"));
}
void
TextSimulation::on_add(const Tokens& arguments)
{
p_stderr(_("\nFIXME: Not implemented"));
p_stderr(_("\nFIXME: Not implemented\n"));
}
void
TextSimulation::on_remove(const Tokens& arguments)
{
p_stderr(_("\nFIXME: Not implemented"));
p_stderr(_("\nFIXME: Not implemented\n"));
}
void
@ -326,7 +408,7 @@ TextSimulation::readline()
}
void
TextSimulation::parse_command(pair< pair<TextSimulation*, IOManager*>, const ustring > p)
TextSimulation::parse_command(TextSimulation& sim, const ustring& str)
{
typedef void (TextSimulation::*f_ptr)(const Tokens&);
map<ustring, f_ptr> command_handlers;
@ -343,25 +425,22 @@ TextSimulation::parse_command(pair< pair<TextSimulation*, IOManager*>, const us
command_handlers["REMOVE"] = &TextSimulation::on_remove;
command_handlers["QUIT"] = &TextSimulation::on_quit;
ustring str = p.second;
Tokens arguments = tokenize(str);
if(arguments.size() == 0)
return;
if(command_handlers.find(arguments[0]) == command_handlers.end())
ustring key = arguments[0].uppercase();
if(command_handlers.find(key) == command_handlers.end())
{
p_stderr(_("\nERROR: command not supported"));
p_stderr(_("\nERROR: command not supported\n"));
return;
}
ustring key = arguments[0].uppercase();
arguments.erase(arguments.begin());
TextSimulation* obj = p.first.first;
(obj->*(command_handlers[key]))(arguments);
(sim.*(command_handlers[key]))(arguments);
}
// ** Please do NOT delete this code, I still use it as a reference **
@ -842,7 +921,10 @@ TextSimulation::_io_loop(pair<TextSimulation* , int > pun)
//Thread::create( sigc::bind(&TextSimulation::parse_command, p), true);
//else
//no read is possible: only write
pun.first->parse_command(p);
// FIXME what was the purpose of this (_io_loop()) method
// need to comment out to make the code compile
//pun.first->parse_command(p);
}
}

4
src/text_simulation.hh
View File

@ -35,6 +35,7 @@
#include <glibmm/thread.h>
#include <glibmm/ustring.h>
#include <utility>
#include <map>
namespace sgpem
@ -107,7 +108,7 @@ namespace sgpem
\li getpolicyattributes <br>
Prints the name and the value of the policy's attributes
*/
static void parse_command(std::pair< std::pair<TextSimulation*, IOManager*>, const Glib::ustring >);
static void parse_command(TextSimulation &sim, const Glib::ustring& str);
/**
Adds an available I/O device.
@ -122,6 +123,7 @@ namespace sgpem
private:
void arguments_ignored(const Tokens& arguments);
void on_run(const Tokens& arguments);
void on_pause(const Tokens& arguments);
void on_stop(const Tokens& arguments);