src/patmos2benchmark.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/AmplInputData.hpp>
#include <pelib/AmplInputScalar.hpp>
#include <pelib/AmplInputVector.hpp>
#include <pelib/AmplInputMatrix.hpp>

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

using namespace pelib;

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)
{
        AmplInput input(AmplInput::floatHandlers());
        AmplOutput output(AmplOutput::floatHandlers());
        Algebra rec;

        // We use an AMPL output, output format
        AlgebraOutput &out = input;

        // Set floating point var output format to fixed at 7 digits
        std::cout << std::setprecision(6)                                                                                                        
        << std::setiosflags(std::ios::fixed)                                                                                                     
        << std::setiosflags(std::ios::showpoint);

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

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

        // Close input file
        myfile.close();

        //out.dump(std::cout, rec);
        std::cout << "# Number of tasks" << std::endl;
        out.dump(std::cout, rec.find<Scalar<float> >("n"));
        std::cout << std::endl << "# Tasks max width" << std::endl;
        out.dump(std::cout, rec.find<Vector<int, float> >("Wi"));
        std::cout << std::endl << "# Tasks workload" << std::endl;
        out.dump(std::cout, rec.find<Vector<int, float> >("Tau"));

        // Scale max processors up to MAX_CORES
        std::cout << std::endl << "# Tasks efficiency" << std::endl;
        std::map<int, std::map<int, float> > map_e = rec.find<Matrix<int, int, float> >("e")->getValues();

        for(std::map<int, std::map<int, float> >::iterator i = map_e.begin(); i != map_e.end(); i++)
        {
                for(int j = 1; j <= MAX_CORES; j++)
                {
                        // Try to fetch e for j processors
                        std::map<int, float>::iterator e_iter = i->second.find(j);

                        // If there is no such value, then the iterator is end()
                        if(e_iter == i->second.end())
                        {
                                i->second.insert(std::pair<int, float>(j, DEFAULT_E));
                        }
                }
        }
        Matrix<int, int, float> e("e", map_e);
        out.dump(std::cout, &e);

#if 0
        // Output one raw value in parameters b, Wi and e
        std::cout << rec.find<Scalar<float> >("b")->getValue() << std::endl;
        std::cout << rec.find<Vector<int, float> >("Wi")->getSize() << std::endl;
        std::cout << rec.find<Matrix<int, int, float> >("e")->getRowSize() << std::endl;

        // Extract, rename and output a few parameters
        Scalar<float> nn(rec.find<Scalar<float> >("n"));
        nn.setName("nn");
        out.dump(std::cout, &nn);

        Vector<int, float> yy(rec.find<Vector<int, float> >("Wi"));
        yy.setName("yy");
        out.dump(std::cout, &yy);
        
        Matrix<int, int, float> ee(rec.find<Matrix<int, int, float> >("e"));
        ee.setName("ee");
        out.dump(std::cout, &ee);
#endif

        return EXIT_SUCCESS;
}