src/crown_binary.cpp

Go to the documentation of this file.

/*
 Copyright 2015 Nicolas Melot

 This file is part of Crown.

 Crown 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.

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

*/


#include <fstream>
#include <set>

#include <cstdlib>

#include <crown/allocation.h>
#include <crown/mapping.h>
#include <crown/scaling.h>
#include <crown/crown.h>
#include <crown/CrownScheduler.hpp>

#include <pelib/XMLSchedule.hpp>
#include <pelib/AmplInput.hpp>
#include <pelib/AmplOutput.hpp>
#include <pelib/Vector.hpp>
#include <pelib/Matrix.hpp>
#include <pelib/Set.hpp>
#include <pelib/GraphML.hpp>
#include <pelib/Schedule.hpp>

#ifdef debug
#undef debug
#endif
#if 0
#define debug(var) cout << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << #var << " = \"" << var << "\"" << endl;
#else
#define debug(var)
#endif

using namespace std;
using namespace pelib;
using namespace pelib::crown;

// Quality assessment parameters
const long long int nsec_in_sec = 1000000000;

typedef struct
{
        double alpha, alpha_static, zeta, epsilon;
        char *taskgraph, *platform;
        bool label;
} args_t;

static args_t
parse_arguments(char **argv)
{
        args_t args;

        // Default values
        args.alpha = 3;
        args.alpha_static = args.alpha;
        args.zeta = 0.1;
        args.epsilon = 0.5;
        args.taskgraph = NULL;
        args.platform = NULL;
        args.label = false;

        for(argv++; argv[0] != NULL; argv++)
        {
                if(string(argv[0]).compare(string("--alpha")) == 0)
                {
                        argv++;
                        args.alpha = atof(argv[0]);
                        continue;                       
                }
                if(string(argv[0]).compare(string("--alpha-static")) == 0)
                {
                        argv++;
                        args.alpha_static = atof(argv[0]);
                        continue;                       
                }
                if(string(argv[0]).compare(string("--zeta")) == 0)
                {
                        argv++;
                        args.zeta = atof(argv[0]);
                        continue;                       
                }
                if(string(argv[0]).compare(string("--epsilon")) == 0)
                {
                        argv++;
                        args.epsilon = atof(argv[0]);
                        continue;                       
                }
                if(string(argv[0]).compare(string("--taskgraph")) == 0)
                {
                        argv++;
                        args.taskgraph = argv[0];
                        continue;                       
                }
                if(string(argv[0]).compare(string("--platform")) == 0)
                {
                        argv++;
                        args.platform = argv[0];
                        continue;                       
                }
                if(string(argv[0]).compare(string("--label")) == 0)
                {
                        args.label = true;
                        continue;
                }
        }

        return args;
}

int
main(int argc, char** argv)
{
        args_t args = parse_arguments(argv);

        if(args.label == false)
        {
                if(args.taskgraph == NULL)
                {
                        cerr << "Missing taskgraph file parameter. Check --taskgraph option." << endl;
                        abort();
                }
                if(args.platform == NULL)
                {
                        cerr << "Missing platform file parameter. Check --platform option." << endl;
                        abort();
                }

                struct timespec seed, total_time;
                clock_gettime(CLOCK_MONOTONIC, &total_time);
                srand(seed.tv_nsec);
                time_t t = time(NULL);
                srand(t);

                cout << setprecision(6) << setiosflags(ios::fixed) << setiosflags(ios::showpoint);
                cerr << setprecision(6) << setiosflags(ios::fixed) << setiosflags(ios::showpoint);

                ifstream taskgraph(args.taskgraph, std::ios::in);
                ifstream platform(args.platform, std::ios::in);

                Algebra alg_arch = AmplInput(AmplInput::floatHandlers()).parse(platform);
                Platform *arch = new Platform(alg_arch);
                Algebra param;
                param.insert(new Scalar<float>("alpha", args.alpha));
                param.insert(new Scalar<float>("zeta", args.zeta));
                param.insert(new Scalar<float>("epsilon", args.epsilon));
                param.insert(new Scalar<float>("alpha-static", args.alpha_static));
                param.insert(new Scalar<float>("b", 2));
                Taskgraph *tg = GraphML().parse(taskgraph);
                taskgraph.close();
                platform.close();

                //cerr << tg->getMakespanCalculator() << " = " << tg->getRoundTime(arch) << endl;
                Algebra schedule = tg->buildAlgebra(arch);
                //AmplInput().dump(cerr, schedule);
                schedule = schedule.merge(arch->buildAlgebra());
                schedule = schedule.merge(param);
                
                // Somehow give alpha, zeta, epsilon and alpha-static (= alpha if nothing is said) to a unique energy model; if alpha-static = zeta = 0, then the model is equivalent to the simple model.
#if !SHOWPOWER
                schedule = crown_binary(schedule, 3);
#else
                schedule = crown_binary(schedule, 0);
#endif
                schedule = CrownScheduler::crownToSchedule(schedule);
                XMLSchedule().dump(cout, Schedule("crown_binary", Schedule::addStartTime(schedule, tg, *arch)), tg, *arch);

                AmplOutput(AmplOutput::floatHandlers()).dump(cerr, Scalar<float>("complexity", crown_binary_complexity(schedule) * (allocation_fastest_complexity(schedule) + mapping_ltlg_complexity(schedule) + frequency_height_complexity(schedule))));

                delete arch;
                delete tg;

                float m = schedule.find<Scalar<float> >("m")->getValue();
                float M = schedule.find<Scalar<float> >("M")->getValue();
                if(m < 0 && M > 0)
                {
                        cerr << "feasible = 0" << endl;
                }
                else
                {
                        cerr << "feasible = 1" << endl;
                }
                
#if !SHOWPOWER
                float qual = mapping_quality(schedule);
                Scalar<float> q("quality", qual);

                AmplOutput(AmplOutput::floatHandlers()).dump(cerr, &q);
                AmplOutput(AmplOutput::floatHandlers()).dump(cerr, schedule.find<Scalar<float> >("_total_solve_elapsed_time"));
#endif
        }
        else
        {
                cout << "Bin,LTLG,Height(a=" << args.alpha << ",";
                if(args.alpha != args.alpha_static)
                {
                        cout << "a_s=" << args.alpha_static << ",";
                }
                cout << "z=" << args.zeta << ",e=" << args.epsilon << ")" << endl;
        }

        return EXIT_SUCCESS;
}