src/CrownMappingILP.cpp

Go to the documentation of this file.

// The following definitions might be exchanged for others,
// when integrating the following code into the framework.
// The code implements a greedy heuristic to loadbalance the tasks
// over cores such that the l2-norm of the load vector is minimized.
// This should also minimize the l3-norm of the load vector.
// J. Keller, July 14, 2014

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <cstdlib>
#include <set>
#include <map>

#include <crown/allocation.h>
#include <crown/mapping.h>
#include <crown/CrownConfigBinary.hpp>
#include <crown/CrownMappingILP.hpp>
#include <crown/CrownException.hpp>

#include <pelib/AmplSolver.hpp>
#include <pelib/Scalar.hpp>
#include <pelib/Vector.hpp>
#include <pelib/Matrix.hpp>
#include <pelib/Set.hpp>
#include <pelib/Schedule.hpp>
#include <pelib/ParseException.hpp>
#include <pelib/Algebra.hpp>

#ifdef debug
#undef debug
#endif

#if 01
#define debug(var) cout << "[" << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "] " << #var << " = \"" << var << "\"" << endl;
#else
#define debug(var)
#endif

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

extern char _binary_mapping_mod_start;
extern char _binary_mapping_mod_end;
extern char _binary_mapping_run_start;
extern char _binary_mapping_run_end;

CrownMappingILP::CrownMappingILP(const CrownConfig *config, const CrownAllocation *alloc, bool showOutput, bool showError) : CrownMapping(config, alloc, showOutput, showError)
{
        /* Do nothing else */
}

CrownMappingILP::CrownMappingILP(const Algebra &param, const CrownConfig *config, const CrownAllocation *alloc, bool showOutput, bool showError): CrownMapping(param, config, alloc, showOutput, showError)
{
        /* Do nothing else */
}

CrownMappingILP::CrownMappingILP(const Taskgraph &tg, const Platform &pt, const Algebra &param, const CrownConfig *config, const CrownAllocation *alloc, bool showOutput, bool showError): CrownMapping(tg, pt, param, config, alloc, showOutput, showError)
{
        /* Do nothing else */
}

Algebra
CrownMappingILP::map(const Algebra &alg, std::map<const string, double> &stats) const
{
        // Build input collection
        std::map<const string, const Algebra> data;
        data.insert(pair<const string, const Algebra>("parameters.dat", alg));

        // Build model and run scripts input streams
        stringstream model(string(&_binary_mapping_mod_start, &_binary_mapping_mod_end));
        stringstream run(string(&_binary_mapping_run_start, &_binary_mapping_run_end));
        
        // Run the solver
        const Algebra *solution = AmplSolver(model, string("model.mod"), run, data, showOutput, showError).solve(stats);

        // Insert back tasks' names
        std::map<const string, double>::iterator ii = stats.find("time");
        if(ii != stats.end())
        {
                double time = ii->second;
                stats.erase(ii);
                stats.insert(pair<const string, double>("time_mapping", time));
        }

        Algebra sol = *solution;
        delete solution;
        return sol;
}

float
CrownMappingILP::complexity(const Taskgraph &tg, const Platform &pt, const Algebra &param, const CrownConfig* config) const
{
        return 0;
}

float
CrownMappingILP::complexity(const pelib::Algebra &input) const
{
        return 0;
}

std::string
CrownMappingILP::getShortDescription() const
{
        stringstream ss;
        std::streamsize p = ss.precision();
        ss.precision(4);
        ss << "ILP";
        ss.precision(p);

        return ss.str();
}

CrownMapping*
CrownMappingILP::clone() const
{
        return new CrownMappingILP(*this);
}