src/crown_binary_simple.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>

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

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

#if 0
static int
timespec_subtract(struct timespec *result, struct timespec *x, struct timespec *y)
{
        /* Perform the carry for the later subtraction by updating y. */
        if (x->tv_nsec < y->tv_nsec)
        {
                int nsec = (y->tv_nsec - x->tv_nsec) / nsec_in_sec + 1;
                y->tv_nsec -= nsec_in_sec * nsec;
                y->tv_sec += nsec;
        }
        if (x->tv_nsec - y->tv_nsec > nsec_in_sec)
        {
                int nsec = (x->tv_nsec - y->tv_nsec) / nsec_in_sec;
                y->tv_nsec += nsec_in_sec * nsec;
                y->tv_sec -= nsec;
        }
     
        /* Compute the time remaining to wait. tv_nsec is certainly positive. */
        result->tv_sec = x->tv_sec - y->tv_sec;
        result->tv_nsec = x->tv_nsec - y->tv_nsec;
     
        /* Return 1 if result is negative. */
        return x->tv_sec < y->tv_sec;
}
#endif

int
main(int argc, char** argv)
{
        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(argv[1], std::ios::in);
        ifstream platform(argv[2], std::ios::in);
        ifstream parameters(argv[3], std::ios::in);

        Algebra alg_arch = AmplInput(AmplInput::floatHandlers()).parse(platform);
        Platform *arch = new Platform(alg_arch);
        Algebra param = AmplInput(AmplInput::floatHandlers()).parse(parameters);
        Taskgraph *tg = GraphML().parse(taskgraph);
        taskgraph.close();
        platform.close();
        parameters.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);
        
#if !SHOWPOWER
        schedule = crown_binary_simple(schedule, 3);
#else
        schedule = crown_binary_simple(schedule, 0);
#endif
        schedule = CrownScheduler::crownToSchedule(schedule);
        XMLSchedule().dump(cout, Schedule("crown_binary", schedule), 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();
        if(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

        return EXIT_SUCCESS;
}