src/PruhsNLP.cpp

Go to the documentation of this file.

/*
 Copyright 2015 Nicolas Melot

 This file is part of Pelib.

 Pelib is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 Pelib 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 Pelib. If not, see <http://www.gnu.org/licenses/>.
*/

#include <string>

#include <pelib/PruhsNLP.hpp>
#include <pelib/AmplSolver.hpp>
#include <pelib/Schedule.hpp>
#include <pelib/XMLSchedule.hpp>
#include <pelib/Scalar.hpp>
#include <pelib/Vector.hpp>
#include <pelib/Matrix.hpp>
#include <pelib/Set.hpp>
#include <pelib/Task.hpp>
#include <pelib/Taskgraph.hpp>
#include <pelib/Platform.hpp>
#include <pelib/CastException.hpp>
#include <pelib/ParseException.hpp>
#include <pelib/AmplOutput.hpp>
#include <pelib/PelibException.hpp>

#define debug(var) cout << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << #var << " = \"" << (var) << "\"" << endl;

using namespace std;
using namespace pelib;

extern char _binary_pruhs_mod_start;
extern char _binary_pruhs_mod_end;
extern char _binary_pruhs_run_start;
extern char _binary_pruhs_run_end;

extern char _binary_pruhs_rescale_mod_start;
extern char _binary_pruhs_rescale_mod_end;
extern char _binary_pruhs_rescale_run_start;
extern char _binary_pruhs_rescale_run_end;

PruhsNLP::PruhsNLP(bool showOutput, bool showError)
{
        param.insert(new Scalar<float>("alpha", 3));
        this->showError = showError;
        this->showOutput = showOutput;
}

PruhsNLP::PruhsNLP(const Algebra &param, bool showOutput, bool showError)
{
        this->param = param;
        this->showError = showError;
        this->showOutput = showOutput;
}

PruhsNLP::PruhsNLP(const Taskgraph &tg, const Platform &pt, const Algebra &param, bool showOutput, bool showError)
{
        this->taskgraph = tg;
        this->platform = pt;
        this->param = param;
        this->showError = showError;
        this->showOutput = showOutput;
}

Schedule
PruhsNLP::schedule(const Taskgraph &tg, const Platform &pt, std::map<const string, double>& stats) const
{
        return schedule(tg, pt, this->param, stats);
}

Schedule
PruhsNLP::schedule(const Taskgraph &tg, const Platform &pt, const Algebra &param, std::map<const string, double>& stats) const
{
        // Add default values, if necessary
        Algebra p = param;
        if(p.find<Scalar<float> >("alpha") == NULL)
        {
                p.insert(new Scalar<float>("alpha", 3));
        }
        
        // Build input collection
        map<const string, const Algebra> data;
        data.insert(pair<const string, const Algebra>(string("platform.dat"), pt.buildAlgebra()));
        data.insert(pair<const string, const Algebra>(string("parameters.dat"), p));

        // Save and remove name vector from data
        Algebra taskgraph = tg.buildAlgebra(pt);
        const Vector<int, string> *name_ptr = taskgraph.find<Vector<int, string> >("name");
        if(name_ptr == NULL)
        {
                throw PelibException("Missing tasks' name vector from taskgraph conversion to Algebra record");
        }
        Vector<int, string> name(*name_ptr);
        taskgraph.remove("name");
        data.insert(pair<const string, const Algebra>(string("taskgraph.dat"), taskgraph));

        // Build model and run scripts input streams
        stringstream model(string(&_binary_pruhs_mod_start, &_binary_pruhs_mod_end));
        stringstream run(string(&_binary_pruhs_run_start, &_binary_pruhs_run_end));

        // Run the solver for the scheduling phase
        const Algebra *solution = AmplSolver(model, string("model.mod"), run, data, this->showOutput, this->showError).solve(stats);
        if(stats.find("feasible")->second != 0)
        {
                stats.erase(stats.find("feasible"));
                map<const string, double>::iterator ii = stats.find("time");
                double pruhs_time = 0;
                if(ii != stats.end())
                {
                        pruhs_time = ii->second;
                }

                data = map<const string, const Algebra>();
                data.insert(pair<const string, const Algebra>(string("input.dat"), *solution));
                delete solution;

                stringstream rescale_model(string(&_binary_pruhs_rescale_mod_start, &_binary_pruhs_rescale_mod_end));
                stringstream rescale_run(string(&_binary_pruhs_rescale_run_start, &_binary_pruhs_rescale_run_end));
                solution = AmplSolver(rescale_model, string("model.mod"), rescale_run, data, this->showOutput, this->showError).solve(stats);
                Algebra alg = Schedule::addStartTime(*solution, tg, pt);

                // Insert back name vector
                alg.insert(new Vector<int, string>(name));
                p = alg.merge(pt.buildAlgebra());

                ii = stats.find("time");
                if(ii != stats.end())
                {
                        double time = ii->second;
                        stats.erase(ii);
                        stats.insert(pair<const string, double>("time_schedule", pruhs_time));
                        stats.insert(pair<const string, double>("time_rescale", time));
                        stats.insert(pair<const string, double>("time_global", pruhs_time + time));
                }
                if(stats.find("feasible")->second != 0)
                {
                        return Schedule("Pruhs NLP", tg.getName(), p);
                }
                else
                {
                        return Schedule("Pruhs NLP", tg.getName(), Schedule::table());
                }
        }
        else
        {
                return Schedule("Pruhs NLP", tg.getName(), Schedule::table());
        }
}

const Algebra*
PruhsNLP::solve() const
{
        map<const string, double> stats;
        return new Algebra(schedule(this->taskgraph, this->platform, this->param, stats).buildAlgebra());
}

const Algebra*
PruhsNLP::solve(map<const string, double> &stats) const
{
        return new Algebra(schedule(this->taskgraph, this->platform, this->param, stats).buildAlgebra());
}

std::string
PruhsNLP::getShortDescription() const
{
        float alpha = this->param.find<Scalar<float> >("alpha")->getValue();
        stringstream ss;

        std::streamsize p = ss.precision();
        ss.precision(4);
        ss << "Pruhs-NLP." << "(a=" << alpha << ")";
        ss.precision(p);

        return ss.str();
}

#ifdef __cplusplus
extern "C" {
#endif

enum config_src {BINARY, ORGAN, TASKGRAPH};

struct args
{
        double alpha;
        size_t fin;
        bool showError, showOutput;
        
};
typedef struct args args_t;

static args_t
parse(char **args)
{
        args_t out;
        out.showError = false;
        out.showOutput = false;
        out.alpha = 3;

        for(; args[0] != NULL; args++)
        {
                if(strcmp(args[0], "--show-stdout") == 0)
                {
                        out.showOutput = true;
                        continue;
                }
                if(strcmp(args[0], "--show-stderr") == 0)
                {
                        out.showError = true;
                        continue;
                }
                if(strcmp(args[0], "--alpha") == 0)
                {
                        args++;
                        stringstream str(args[0]);
                        str >> out.alpha;
                        continue;
                }
        }

        return out;
}

const pelib::Schedule*
pelib_schedule(const pelib::Taskgraph &tg, const pelib::Platform &pt, size_t argc, char **argv, map<const string, double>& statistics)
{
        args_t args = parse(argv);
        Algebra param;
        param.insert(new Scalar<float>("alpha", args.alpha));

        // Convert solver output to general schedule
        Schedule *sched;
        sched = new Schedule(PruhsNLP(param, args.showOutput, args.showError).schedule(tg, pt, statistics));

        return sched;
}

string
pelib_description(size_t argc, char **argv)
{
        args_t args = parse(argv);
        Algebra param;
        param.insert(new Scalar<float>("alpha", args.alpha));

        // Convert solver output to general schedule
        string desc;
        desc = PruhsNLP(param, args.showOutput, args.showError).getShortDescription();

        return desc;
}

void
pelib_delete(pelib::Schedule *sched)
{
        delete sched;
}

#ifdef __cplusplus
}
#endif