src/crownFigureGen.c

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/>.

*/


/*
 * crownFigureGen.c
 *
 *  Created on: 06.06.2013
 *      Author: Patrick Eitschberger
 *
 *  latest update:
 *  05.09.2013
 *  2014-01-30 Fixed inverted reading of matric e, support for bigger matrices than cores, updated max core and tasks
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>

// Control if scanf operation went OK and abort with a message stating line of code if any failure occurred.
#define assert_scanf(expr) { int num = expr; if (num == 0 || num == EOF) { fprintf(stderr, "[%s:%s:%d] Error while reading input. Aborting.\n", __FILE__, __FUNCTION__, __LINE__); abort(); }}

static int MAXTASKS = 2000; //upper bound for number of tasks
static int MAXCORES = 1024; //upper bound for number of cores
static int FIGUREHEIGHT = -1;
static int SHOWGROUPS = 1; // include the grouporder in the figure
static char filenameDat[500];
static char filenameOut[500];
static char filenameFig[500];

#define printf_int(var) printf("[DEBUG][%s:%s:%d] %s = %d\n", __FILE__, __FUNCTION__, __LINE__, #var, var);
#define printf_llint(var) printf("[DEBUG][%s:%s:%d] %s = %lld\n", __FILE__, __FUNCTION__, __LINE__, #var, var);
#define printf_float(var) printf("[DEBUG][%s:%s:%d] %s = %f\n", __FILE__, __FUNCTION__, __LINE__, #var, var);

struct task /* task properties */
{
        int taskIndex;
        int groupIndex;
        int workload;
        int coresInGroup;
        float efficiency;
        int frequencyOfTask;
        float runtime;
        struct task *next;
        struct task *previous;
};
typedef struct task Task;

static void readfiles(int *L, int *b, int *n, int tau[MAXTASKS], int *corecount, float e[MAXTASKS][MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], float *M);
static void createGroupSizes(int groupOrder[MAXCORES*2], int corecount);
static Task *fillTasklist(Task *tasklist, int tau[MAXTASKS], float e[MAXTASKS][MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], int n, int groupOrder[MAXCORES*2]);
static void generateFigureFile(Task * tasklist, int corecount, float M);
//static void displayOutputs(int L, int b, int n, int corecount, int tau[MAXTASKS], float e[MAXTASKS][MAXCORES], float time[MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], int groupOrder[MAXCORES*2], Task *tasklist, float M);

int main(int argc, char **argv)
{
        int L = 0;
        int b = 0;
        int n = 0;
        int corecount = 1;
        int tau[MAXTASKS];
        float e[MAXTASKS][MAXCORES];
        float M = 0.0;
        //float time[MAXCORES];
        int group[MAXTASKS];
        int frequency[MAXTASKS];
        int groupOrder[MAXCORES*2];
        Task *tasklist = NULL;
        Task *deleteElement = NULL;

        /* Safe arguments */
        if(argc == 1)
        {
                fprintf(stderr, "Too few arguments. Please set the filepath (including the filename).\n");
                exit(1);
        }
        else if(argc == 2)
        {
                sprintf(filenameDat, "%s", argv[1]);
                //printf("%s\n", filenameDat);
        }
        else if(argc == 3)
        {
                sprintf(filenameDat, "%s", argv[1]);
                //printf("%s\n", filenameDat);
                SHOWGROUPS = atoi(argv[2]);

        }
        else if(argc == 4)
        {
                sprintf(filenameDat, "%s", argv[1]);
                //printf("%s\n", filenameDat);
                SHOWGROUPS = atoi(argv[2]);
                FIGUREHEIGHT = atoi(argv[3]);
        }
        else
        {
                printf("Too many arguments\n");
                exit(2);
        }

        readfiles(&L, &b, &n, tau, &corecount, e, group, frequency, &M);
        createGroupSizes(groupOrder, corecount);
        tasklist = fillTasklist(tasklist, tau, e, group, frequency, n, groupOrder);
        generateFigureFile(tasklist, corecount, M); //in xfig-format
        //displayOutputs(L, b, n, corecount, tau, e, time, group, frequency, groupOrder, tasklist, M);

        while(tasklist->next != NULL)
        {
                deleteElement = tasklist;
                tasklist = tasklist->next;
                free(deleteElement);
        }

        return 0;
}

/* reads the inputs from the dat- and out-files (frequency.dat/.out and integrated.dat/out) */
void readfiles(int *L, int *b, int *n, int tau[MAXTASKS], int *corecount, float e[MAXTASKS][MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], float *M)
{
        int i = 0;
        int j = 0;
        char line[250];
        size_t length;
        FILE *datfile = fopen(filenameDat, "r");
        length = strlen(filenameDat);
        strncpy(filenameOut, filenameDat, length - 4);
        strcat(filenameOut, ".out");
        FILE *outfile = fopen(filenameOut, "r");
        if (datfile != NULL && outfile != NULL) /* if the files exist... */
        {
                /* values from the datfile */

                /* read param L,b,n */
                assert_scanf(fscanf(datfile,"%s %s %s", &line[0], &line[0], &line[0]));
        
                assert_scanf(fscanf(datfile,"%d %s\n", L, &line[0]));
                assert_scanf(fscanf(datfile,"%s %s %s", &line[0], &line[0], &line[0]));
                assert_scanf(fscanf(datfile,"%d %s", b, &line[0]));
                assert_scanf(fscanf(datfile,"%s %s %s", &line[0], &line[0], &line[0]));
                assert_scanf(fscanf(datfile,"%d %s", n, &line[0]));

                /* go to line with param tau */
                while(strcmp(line,"workload"))
                {
                        assert_scanf(fscanf(datfile,"%s", &line[0]));
                }

                /* read param tau */
                for(i = 0; i < *n; i++)
                {
                        assert_scanf(fscanf(datfile,"%*d %d", &tau[i]));
                        //fprintf(stderr, "Task %d gets tau %d\n", i + 1, tau[i]);
                }

                /* go to line with param e */
                while(strcmp(line,":="))
                {
                        assert_scanf(fscanf(datfile,"%s", &line[0]));
                }

                for(i = 0; i < *L; i++)
                        *corecount = *corecount * 2;
                

                /* read param e */
                for(i = 0; i < *n; i++)
                {
                        assert_scanf(fscanf(datfile,"%*d"));
                        for(j = 0; j < *corecount; j++)
                        {
                                assert_scanf(fscanf(datfile,"%f", &e[i][j]));
                        }
                        while(fgetc(datfile) != '\n');
                        
                }

                /* set line to 0 because it is also ":=" before */
                sprintf(line, "0");

                /* go to line with param M */
                while(strcmp(line,"parameters"))
                {
                        assert_scanf(fscanf(datfile,"%s", &line[0]));
                }

                /* read param M */
                assert_scanf(fscanf(datfile,"%s %s %s", &line[0], &line[0], &line[0]));
                assert_scanf(fscanf(datfile,"%f %s\n", M, &line[0]));

                fclose(datfile);

                /* values from the out-file */

                /* set line to 0 because it is also ":=" before */
                sprintf(line, "0");

                /* go to line with step-time (frequency.out) or int-time (integrated.out) */
                while(strcmp(line,":="))
                {
                        assert_scanf(fscanf(outfile,"%s", &line[0]));
                }

                /* read param time */
                for(i = 0; i < *corecount; i++)
                {
                        float a;
                        assert_scanf(fscanf(outfile,"%*d %f", &a));
                }

                /* set line to 0 because it is also ":=" before */
                sprintf(line, "0");

                /* go to line with step-group (frequency.out) or int-group (integrated.out) */
                while(strcmp(line,":="))
                {
                        assert_scanf(fscanf(outfile,"%s", &line[0]));
                }

                /* read param group */
                int task, tmp;
                for(i = 0; i < *n; i++)
                {
                        assert_scanf(fscanf(outfile,"%d %d", &task, &tmp));
                        group[task - 1] = tmp;
                        //fprintf(stderr, "Task %d gets group %d\n", task, group[task-1]);
                }

                /* set line to 0 because it is also ":=" before */
                sprintf(line, "0");

                /* go to line with step-frequency (frequency.out) or int-frequency (integrated.out) */
                while(strcmp(line,":="))
                {
                        assert_scanf(fscanf(outfile,"%s", &line[0]));
                }

                /* read param frequency */
                for(i = 0; i < *n; i++)
                {
                        assert_scanf(fscanf(outfile,"%d %d", &task, &tmp));
                        frequency[task - 1] = tmp;
                        //fprintf(stderr, "Task %d gets frequency %d\n", task, frequency[task-1]);
                }
                fclose(outfile);
        }
}

/* create the order of the groups */
void createGroupSizes(int groupOrder[MAXCORES*2],int corecount)
{
        int i = 0;
        int j = 1;
        int step = 0;
        for(i = 0; i < corecount * 2 - 1 ; i++)
        {
                if(step == j)
                {
                        step = 0;
                        j = j * 2;
                }
                groupOrder[i] = corecount/j;
                //printf("%d -> %d\n", i, groupOrder[i]);
                step++;
        }
}

/* creates a list of tasks sorted by their groupIndex */
Task *fillTasklist(Task *tasklist, int tau[MAXTASKS], float e[MAXTASKS][MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], int n, int groupOrder[MAXCORES*2])
{
        Task *newtask = NULL;
        Task *currenttask = NULL;
        int i = 0;

        /* create n task-elements and insert them in the tasklist sorted by groupindex first and then by taskindex */
        for(i = 0; i < n; i++)
        {
                newtask = malloc(sizeof(Task));
                newtask->taskIndex = i+1;
                newtask->groupIndex = group[i];
                newtask->workload = tau[i];
                newtask->coresInGroup = groupOrder[newtask->groupIndex - 1];
                newtask->efficiency = e[i][newtask->coresInGroup - 1];
                newtask->frequencyOfTask = frequency[i];
                newtask->runtime = newtask->workload / newtask->efficiency;
                newtask->runtime = newtask->runtime / newtask->coresInGroup;
                newtask->runtime = newtask->runtime / newtask->frequencyOfTask;
                //newtask->runtime = ((newtask->workload / newtask->efficiency) / newtask->coresInGroup) / newtask->frequencyOfTask;
                newtask->next = NULL;
                newtask->previous = NULL;

#if 0
struct task /* task properties */
{
        int taskIndex;
        int groupIndex;
        int workload;
        int coresInGroup;
        float efficiency;
        int frequencyOfTask;
        float runtime;
        struct task *next;
        struct task *previous;
};

                if(newtask->runtime > 10000)
                {
                        printf_int(newtask->groupIndex);
                        printf_int(newtask->coresInGroup);
                        printf_int(newtask->taskIndex);
                        printf_int(newtask->workload);
                        printf_float(newtask->efficiency);
                        printf_int(newtask->coresInGroup);
                        printf_int(newtask->frequencyOfTask);
                        printf_float(newtask->runtime);
                        printf_float(newtask->workload / newtask->efficiency / newtask->coresInGroup / newtask->frequencyOfTask);
                        printf_int(newtask->workload / newtask->efficiency / newtask->coresInGroup / newtask->frequencyOfTask);

                        abort();
                }
#endif

                if (tasklist == NULL)
                        tasklist = newtask;
                else
                {
                        currenttask = tasklist;
                        while(currenttask->groupIndex <= newtask->groupIndex && currenttask->next != NULL)
                                currenttask = currenttask->next;
                        if(currenttask->groupIndex > newtask->groupIndex)
                        {
                                if(currenttask->previous == NULL)
                                {
                                        newtask->next = currenttask;
                                        currenttask->previous = newtask;
                                        tasklist = newtask;
                                }
                                else
                                {
                                        currenttask->previous->next = newtask;
                                        newtask->previous = currenttask->previous;
                                        newtask->next = currenttask;
                                        currenttask->previous = newtask;
                                }
                        }
                        else
                        {
                                currenttask->next = newtask;
                                newtask->previous = currenttask;
                        }
                }
        }
        return tasklist;
}

/* generate *.fig file with the information from the tasklist */
void generateFigureFile(Task * tasklist, int corecount, float M)
{
        float realtime[MAXCORES];
        int i = 0;
        int corewidth = 1000;
        Task *currenttask = NULL;
        int taskwidth = 0;
        int taskheight = 0;
        int x = 0;
        int y = 0;
//      float biggesttime = 0.0; CHANGED LIKE FAVORED FROM NICOLAS (21.06.13)
        int scheduleheight = 0;
        int groupCountPerLine = 0;
        int groupHeight[corecount * 2];
        int xOffset = 1000;
        int yOffset = 100;
        int barrierwidth = 0;
        int barrierheight = 284;
        int startCore = 0;
        size_t length;

        int scalingfactor = 0;

        //calculate scalingfactor for the taskheight and scheduleheight
        if(FIGUREHEIGHT != -1) // if the figure height is given as param to this program calculate the scalingfactor
        {
                scalingfactor = (int)((FIGUREHEIGHT - (2 * barrierheight + 500))/M);
        }
        else // use 1000 as scalingfactor
                scalingfactor = 1000;
//      printf("scalingfactor = %d\n", scalingfactor);


        length = strlen(filenameDat);
        strncpy(filenameFig, filenameDat, length - 4);
        strcat(filenameFig, ".fig");
//      FILE *figfile = fopen(filenameFig, "w");
        FILE *figfile = stdout;

        /* standard outputs for the file properties */
        fprintf(figfile, "#FIG 3.2\n");
        fprintf(figfile, "#generated by Patrick Eitschberger\n");
        fprintf(figfile, "Portrait\n");
        fprintf(figfile, "Center\n");
        fprintf(figfile, "Metric\n");
        fprintf(figfile, "A4\n");
        fprintf(figfile, "100.0\n");
        fprintf(figfile, "Single\n");
        fprintf(figfile, "-2\n");
        fprintf(figfile, "1200 2\n");

        /* Calculate the running times for each core */
        for(i = 0; i < corecount; i++)
                realtime[i] = 0.0;
        currenttask = tasklist;
        while(currenttask != NULL)
        {
                startCore = (currenttask->groupIndex - (corecount/currenttask->coresInGroup)) * currenttask->coresInGroup;
                for(i = startCore; i < startCore + currenttask->coresInGroup; i++)
                        realtime[i] = realtime[i] + currenttask->runtime;
                currenttask = currenttask->next;
        }

//      CHANGED LIKE FAVORED FROM NICOLAS (21.06.13) /* Calculate the height of the whole schedule */
//      for(i = 0; i < corecount; i++)
//              if(realtime[i] > biggesttime)
//                      biggesttime = realtime[i];
//      scheduleheight = biggesttime * scalingfactor + yOffset + barrierheight;

        scheduleheight = M * scalingfactor;
        scheduleheight = scheduleheight + yOffset;
        scheduleheight = scheduleheight + barrierheight;

        /* include time-arrow on the left side with describtion "time" */
        fprintf(figfile,"2 1 0 2 0 7 1 0 -1 6.000 0 0 0 0 1 2\n");
        fprintf(figfile,"2 1 2.00 120.00 240.00\n");
        fprintf(figfile,"%d %d %d %d\n", xOffset, yOffset + barrierheight, xOffset, scheduleheight - barrierheight);
        fprintf(figfile, "4 0 0 1 0 1 18 0.0000 4 303 1000 %d %d time\\001\n\n", 200, yOffset + barrierheight + 200);
        xOffset = xOffset *2;

        /* include the upper barrier */
        barrierwidth = corewidth * corecount + xOffset + 100;
        fprintf(figfile, "2 2 1 2 0 20 1 0 20 6.000 0 0 7 0 0 5\n");
        fprintf(figfile, "%d %d %d %d %d %d %d %d %d %d\n\n", xOffset, yOffset, barrierwidth, yOffset, barrierwidth, yOffset + barrierheight, xOffset, yOffset + barrierheight, xOffset, yOffset);
        fprintf(figfile, "4 0 0 1 0 1 18 0.0000 4 500 1000 %d %d barrier\\001\n\n", barrierwidth + 100, yOffset + barrierheight );

        /* include tasks as rectangles with describtion "task xy" */
        currenttask = tasklist;
        for(i = 0; i < corecount * 2; i++)
                groupHeight[i] = scheduleheight;
        while(currenttask != NULL)
        {
//              printf("Gruppe %d: Task %d: gruppenhoehe = %d, niedrigereGruppenhoehe = %d (gruppe %d)\n", currenttask->groupIndex, currenttask->taskIndex, groupHeight[currenttask->groupIndex - 1], groupHeight[currenttask->groupIndex /2], currenttask->groupIndex/2);
                if(currenttask->groupIndex != 1 && groupHeight[currenttask->groupIndex - 1] > groupHeight[currenttask->groupIndex / 2 - 1])
                        groupHeight[currenttask->groupIndex - 1] = groupHeight[currenttask->groupIndex /2 - 1];
                y = groupHeight[currenttask->groupIndex - 1];
                taskwidth = corewidth * currenttask->coresInGroup;
                taskheight = currenttask->runtime * scalingfactor;

#if 0
                if(y - taskheight < 0)
                {
                        printf_float(currenttask->runtime);
                        printf_int(scalingfactor);

                        printf_llint(taskheight);
                        printf_llint(y);
                        printf_llint(y - taskheight);

                        abort();
                }
#endif

                groupCountPerLine = corecount/currenttask->coresInGroup;
                x = (currenttask->groupIndex - groupCountPerLine) * taskwidth + xOffset;
                fprintf(figfile, "2 2 0 2 0 26 3 0 %d 4.000 0 0 7 0 0 5\n", 35 - currenttask->frequencyOfTask * 5);
                fprintf(figfile, "%d %d %d %d %d %d %d %d %d %d\n\n", x, y - taskheight, x + taskwidth, y - taskheight, x + taskwidth, y, x, y, x, y - taskheight);
                fprintf(figfile, "4 1 0 1 0 0 18 0.0000 4 303 900 %d %d task %d\\001\n\n", x + taskwidth/2, y - taskheight/2 + 80 + 18, currenttask->taskIndex);
                groupHeight[currenttask->groupIndex - 1] = groupHeight[currenttask->groupIndex - 1] - taskheight;

                //      BUGFIX (05.09.13) /* changes the height of all groups that are placed over the current group  */
                for(i = 2; i <= corecount * 2; i++)
                        if(groupHeight[i - 1] > groupHeight[i / 2 - 1])
                                groupHeight[i - 1] = groupHeight[i / 2 - 1];
                currenttask = currenttask->next;
        }

        /* include the lower barrier */
        barrierwidth = corewidth * corecount + xOffset + 100;
        fprintf(figfile, "2 2 1 2 0 20 1 0 20 6.000 0 0 7 0 0 5\n");
        fprintf(figfile, "%d %d %d %d %d %d %d %d %d %d\n\n", xOffset, scheduleheight, barrierwidth , scheduleheight, barrierwidth , scheduleheight + barrierheight, xOffset, scheduleheight + barrierheight, xOffset, scheduleheight);
        fprintf(figfile, "4 0 0 1 0 1 18 0.0000 4 303 1000 %d %d barrier\\001\n\n", barrierwidth + 100, scheduleheight + barrierheight );

        /* include a scale for the number of processors */
        y = scheduleheight + barrierheight;
        for(i = 0; i <= corecount; i++)
        {
                fprintf(figfile, "2 1 0 2 0 7 1 0 -1 6.000 0 0 0 0 0 2\n");
                fprintf(figfile, "%d %d %d %d\n\n", xOffset + i * corewidth, y, xOffset + i * corewidth, y + 200);
                if(i < corecount)
                {
                        fprintf(figfile, "4 0 0 1 0 1 18 0.0000 4 500 615 %d %d P%d\\001\n\n", xOffset + i * corewidth + 450, y + 400, i + 1);
                        fprintf(figfile, "2 1 1 1 0 7 2 0 -1 6.000 0 0 0 0 0 2\n");
                        fprintf(figfile, "%d %d %d %d\n\n", xOffset + (i + 1) * corewidth, scheduleheight - (int) (realtime[i] * scalingfactor), xOffset + (i + 1) * corewidth, scheduleheight + barrierheight + 200);
                }
        }

        //      UPDATE (05.09.13) /* include grouporder for better understanding */
        if(SHOWGROUPS == 1)
        {
                int groupsinrow = corecount;
                y = y + 750;
                for(i = corecount * 2 - 1; i > 0 ; i--)
                {
                        if(i >= groupsinrow)
                        {
                                x = xOffset + (i - groupsinrow) * (corewidth * corecount / groupsinrow);
                                fprintf(figfile, "2 2 0 2 0 26 3 0 -1 4.000 0 0 7 0 0 5\n");
                                fprintf(figfile, "%d %d %d %d %d %d %d %d %d %d\n\n", x, y, x + (corewidth * corecount / groupsinrow), y, x + (corewidth * corecount / groupsinrow), y + barrierheight, x, y + barrierheight, x, y);
                                fprintf(figfile, "4 1 0 1 0 0 18 0.0000 4 303 900 %d %d %d\\001\n\n", x + (corewidth * corecount / groupsinrow)/2, y + barrierheight/2 + 80 + 18, i);
                        }
                        if(i == groupsinrow)
                        {
                                if(groupsinrow == corecount/4)
                                        fprintf(figfile, "4 0 0 1 0 1 18 0.0000 4 303 1000 %d %d groups\\001\n\n", xOffset + corecount * corewidth + 100, y + barrierheight );
                                groupsinrow = groupsinrow / 2;
                                y = y + barrierheight;
                        }
                }
        }

        //      UPDATE (05.09.13) /* include frequency legend */
        if(SHOWGROUPS == 1)
                y = y + 500;
        else
                y = y + 750;
        fprintf(figfile, "4 0 0 1 0 1 18 0.0000 4 500 615 %d %d frequencies\\001\n\n", xOffset + corewidth * corecount - 5  * corewidth, y);
        y = y + 150;
        for(i = 1; i < 6; i++)
        {
                fprintf(figfile, "2 2 0 2 0 26 3 0 %d 4.000 0 0 7 0 0 5\n", 35 - i * 5);
                fprintf(figfile, "%d %d %d %d %d %d %d %d %d %d\n\n", xOffset + corewidth * corecount - (6 - i) * corewidth, y, xOffset + corewidth * corecount - (6 - i - 1) * corewidth, y, xOffset + corewidth * corecount - (6 - i - 1) * corewidth, y + barrierheight, xOffset + corewidth * corecount - (6 - i) * corewidth, y + barrierheight, xOffset + corewidth * corecount - (6 - i) * corewidth, y);
                fprintf(figfile, "4 1 0 1 0 0 18 0.0000 4 303 900 %d %d %d\\001\n\n", xOffset + corewidth * corecount - (6 - i) * corewidth + corewidth/2, y + barrierheight/2 + 80 + 18, i);
        }

        /* include a white rectangle around the figure to get a bigger screen for the eps and png files*/
        fprintf(figfile, "2 2 0 4 7 7 1 0 -1 4.000 0 0 7 0 0 5\n");
                fprintf(figfile, "%d %d %d %d %d %d %d %d %d %d\n\n", 1, 1, barrierwidth + 1000, 1, barrierwidth + 1000, y + 500, 1, y + 500, 1,1);

}

/* print some informations on the screen... only for checking correctness */
/*
void displayOutputs(int L, int b, int n, int corecount, int tau[MAXTASKS], float e[MAXTASKS][MAXCORES], float time[MAXCORES], int group[MAXTASKS], int frequency[MAXTASKS], int groupOrder[MAXCORES*2], Task *tasklist, float M)
{
        int i = 0;
        int j = 0;
        Task *currenttask = NULL;

        printf("param L := %d\n", L);
        printf("param b := %d\n", b);
        printf("param n := %d\n", n);
        printf("\nparam: Tau := # Task workload\n");
        for(i = 0; i < n; i++)
                printf("%d %d\n", i, tau[i]);
        printf("\nparam e: # Task efficiency for a given amount of cores, generated constant function\n");
        for(i = 0; i < n; i++)
        {
                for(j = 0; j < corecount; j++)
                        printf("%.6f ", e[i][j]);
                printf("\n");
        }
        printf("\n*_time [*] :=\n");
        for(i = 0; i < corecount; i++)
                printf("%d %f\n", i, time[i]);
        printf("\n*_group [*] :=\n");
        for(i = 0; i < n; i++)
                printf("%d %d\n", i+1, group[i]);
        printf("\n*_frequency [*] :=\n");
        for(i = 0; i < n; i++)
                printf("%d %d\n", i+1, frequency[i]);
        printf("\nGroupOrder =\n");
        for(i = 0; i < corecount * 2 - 1; i++)
                printf("%d %d\n", i+1, groupOrder[i]);

        printf("\nTasklist =\n");
        currenttask = tasklist;
        while(currenttask != NULL)
        {
                printf("Group %d: task %d, runtime %f, workload %d, cores %d, efficiency %f, frequency %d, \n", currenttask->groupIndex, currenttask->taskIndex, currenttask->runtime, currenttask->workload, currenttask->coresInGroup, currenttask->efficiency, currenttask->frequencyOfTask);
                currenttask = currenttask->next;
        }
        printf("\nCost Parameters =\n");
        printf("param M := %f\n", M);
}
*/