src/crowngen_out.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 <iostream>
#include <cstdlib>
#include <fstream>
#include <string>
#include <boost/regex.hpp>
#include <iomanip>

#include <pelib/AmplInput.hpp>
#include <pelib/AmplOutput.hpp>

#include <pelib/AmplOutputScalar.hpp>
#include <pelib/AmplOutputVector.hpp>
#include <pelib/AmplOutputSet.hpp>
#include <pelib/AmplOutputMatrix.hpp>

#include <pelib/AmplInputScalar.hpp>
#include <pelib/AmplInputVector.hpp>
#include <pelib/AmplInputSet.hpp>
#include <pelib/AmplInputMatrix.hpp>

using namespace pelib;
using namespace std;

const int b = 2;

typedef map<int, int> TaskWidthVector;
typedef map<int, int> TaskScheduleVector;
typedef map<int, TaskScheduleVector> ProcScheduleMatrix;

int
group_size(int group, int p, int b)
{
        return (int)(p / pow(b, floor((log(group) / log(b)))));
}

Algebra
parse(AlgebraParser &parser, std::istream &input)
{
        Algebra rec;
        
        try {
                rec = parser.parse(input);
        } catch(ParseException &e)
        {
                std::cerr << e.what() << std::endl;
        }

        return rec;
}

int
main(int argc, char **argv)
{
        AmplOutput input(AmplOutput::floatHandlers());
        AmplOutput output(AmplOutput::floatHandlers());
        Algebra rec;

        // Open input file
        //std::ifstream myfile;
        //myfile.open (argv[1], std::ios::in);

        // Load input file
        //rec = parse(input, myfile);
        rec = parse(input, cin);

        // Close input file
        //myfile.close();

        cout << setprecision(6)
        << setiosflags(ios::fixed)
        << setiosflags(ios::showpoint);
        
        Vector<int, float> group("step_group", rec.find<Vector<int, float> >("group")->getValues());
        Vector<int, float> frequency("step_frequency", rec.find<Vector<int, float> >("frequency")->getValues());

        cout << "option show_stats 0; \n\
\n\
Presolve eliminates 29 constraints and 3 variables.\n\
Substitution eliminates 191 variables.\n\
Adjusted problem:\n\
377 variables:\n\
        314 binary variables\n\
        63 linear variables\n\
131 constraints, all linear; 740 nonzeros\n\
1 linear objective; 314 nonzeros.\n\
\n\
Gurobi 5.1.0: timelim 300\n\
Gurobi 5.1.0: optimal solution; objective 329.92\n\
plus 63 simplex iterations for intbasis\n\
Time after optimization:\n\
step_time [*] :=\n\
 1  0    5  6    9  2   13 16   17  5   21  8   25  5   29  3\n\
 2  4    6  3   10  6   14  8   18 18   22  4   26 17   30  2\n\
 3  2    7  3   11  9   15  2   19  3   23  4   27  1   31  5\n\
 4  1    8  7   12  4   16  3   20  6   24 11   28  4   32  4\n\
;\n\
\n\
Static, dynamic and combined energy:\n\
step_static = 41.92\n\
\n\
step_dynamic = 288\n\
\n\
step_energy = 329.92\n\
\n\
Task mapping to core groups and frequency:" << endl;

        output.dump(cout, &group);
        cout << endl;
        output.dump(cout, &frequency);

        cout << endl;
        cout << "# time: 0.50049090385437" << endl;
        cout << endl;
        
        return EXIT_SUCCESS;
}