src/crowngen_dat.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;
}

void
printf_int_float_vector(map<int, float> vect)
{
        for(map<int, float>::iterator i = vect.begin(); i != vect.end(); i++)
        {
                cout << i->first << " " << i->second << endl;
        }
        cout << ";" << endl;
}

int
main(int argc, char **argv)
{
        AmplInput input(AmplInput::floatHandlers());
        AmplInput output(AmplInput::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);
        
        //int n = rec.find<Scalar<float> >("n")->getValue();
        int p = (int)rec.find<Scalar<float> >("p")->getValue();
        int b = (int)rec.find<Scalar<float> >("b")->getValue();
        //Scalar<float> alpha("alpha", (float)rec.find<Scalar<float> >("alpha")->getValue());
        Scalar<float> alpha("alpha", 3.0);
        Scalar<float> L("L", (int)(log(p) / log(b)));
        Scalar<float> R("R", (float)(0.3));
//      Vector<int, float> yy("yy", rec.find<Vector<int, float> >("group")->getValues());
        map<int, float> vector_tau = rec.find<Vector<int, float> >("Tau")->getValues();
        
        // Outputs all useful information for schedule evaluation
        output.dump(cout, &L);
        output.dump(cout, rec.find<Scalar<float> >("b"));
        output.dump(cout, rec.find<Scalar<float> >("n"));
        cout << endl;
        output.dump(cout, rec.find<Vector<int, float> >("Wi"));
        cout << endl;
        cout << "param: Tau := # Task workload" << endl;
        printf_int_float_vector(vector_tau);
        cout << endl;
        output.dump(cout, rec.find<Matrix<int, int, float> >("e"));
        cout << endl;
        cout << "#";
        output.dump(cout, rec.find<Scalar<float> >("zeta"));
        cout << "#";
        output.dump(cout, &alpha);
        cout << "#";
        output.dump(cout, &R);
        cout << "#";
        {
                const Scalar<float> *M = rec.find<Scalar<float> >("M");
                if(M != NULL)
                {
                        output.dump(cout, M);
                }
        }
        {
                const Scalar<float> *M = rec.find<Scalar<float> >("M");
                if(M != NULL)
                {
                        output.dump(cout, M);
                }
        }
        cout << "#";
        output.dump(cout, rec.find<Set<float> >("F"));
        cout << endl;
        cout << endl;
        //output.dump(cout, rec.find<Vector<int, float> >("wi"));
        cout << endl;
        cout << endl;
        cout << endl;
//      output.dump(cout, &yy);
        cout << "## Frequency" << endl;
        output.dump(cout, rec.find<Set<float> >("F"));
        output.dump(cout, &alpha);
        cout << endl;
        cout << "## Cost parameters" << endl;
        output.dump(cout, rec.find<Scalar<float> >("M"));
        output.dump(cout, rec.find<Scalar<float> >("zeta"));
        
        return EXIT_SUCCESS;
}