src/crown_binary_annealing_allocation_off.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/annealing.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 pelib;
using namespace pelib::crown;
using namespace std;

int
main(int argc, char** argv)
{
        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();

        Algebra schedule = tg->buildAlgebra(arch);
        schedule = schedule.merge(arch->buildAlgebra());
        schedule = schedule.merge(param);

        schedule = crown_binary_annealing_allocation_off(schedule, 8, 0.6, 0.9, 2, 2, 0.5);
        schedule = CrownScheduler::crownToSchedule(schedule);

        XMLSchedule().dump(cout, Schedule("crown_binary_annaling_allocation_", schedule), tg, *arch);
        /*
        cerr << allocation_fastest_complexity(schedule) << endl;
        cerr << mapping_ltlg_complexity(schedule) << endl;
        cerr << frequency_height_complexity(schedule) << endl;
        cerr << allocation_fastest_complexity(schedule) + mapping_ltlg_complexity(schedule) + frequency_height_complexity(schedule) << endl;
        cerr << crown_binary_complexity(schedule) << endl;
        cerr << annealing_complexity(8, 0.6, 0.9, 2, 2, 0.5) << endl;           
        cerr << crown_binary_complexity(schedule) + annealing_complexity(8, 0.6, 0.9, 2, 2, 0.5) << endl;
        */
        AmplOutput(AmplOutput::floatHandlers()).dump(cerr, Scalar<float>("complexity", (crown_binary_complexity(schedule) + annealing_complexity(8, 0.6, 0.9, 2, 2, 0.5)) * (allocation_fastest_complexity(schedule) + mapping_ltlg_complexity(schedule) + frequency_height_complexity(schedule))));

        float qual = mapping_quality(schedule);
        Scalar<float> q("quality", qual);

        float m = schedule.find<Scalar<float> >("m")->getValue();
        if(m < 0)
        {
                cerr << "feasible = 0" << endl;
        }
        else
        {
                cerr << "feasible = 1" << endl;
        }
        
        AmplOutput(AmplOutput::floatHandlers()).dump(cerr, &q);
        AmplOutput(AmplOutput::floatHandlers()).dump(cerr, schedule.find<Scalar<float> >("_total_solve_elapsed_time"));

        return EXIT_SUCCESS;
}