// Copyright (c) 2014 Carnegie Mellon University.
// All Rights Reserved.
// Redistribution and use in source and binary forms,
// with or without modification, are permitted provided that the
// following conditions are met:
// 1. Redistributions of source code must retain the above 
//    copyright notice, this list of conditions and the following
//    acknowledgments and disclaimers.
// 2. Redistributions in binary form must reproduce the above 
//    copyright notice, this list of conditions and the following
//    acknowledgments and disclaimers in the documentation and/or
//    other materials provided with the distribution.
// 3. Products derived from this software may not include
//    “Carnegie Mellon University,” "SEI” and/or “Software
//    Engineering Institute" in the name of such derived product,
//    nor shall “Carnegie Mellon University,” "SEI” and/or 
//    “Software Engineering Institute" be used to endorse or 
//    promote products derived from this software without prior 
//    written permission. For written permission, please contact
//    permission@sei.cmu.edu.
// ACKNOWLEDGMENTS AND DISCLAIMERS:
// This material is based upon work funded and supported by the
// Department of Defense under Contract No. FA8721-05-C-0003 
// with Carnegie Mellon University for the operation of the  
// Software Engineering Institute, a federally funded research
// and development center.
// Any opinions, findings and conclusions or recommendations 
// expressed in this material are those of the author(s) and do
// not necessarily reflect the views of the United States
// Department of Defense.
// References herein to any specific commercial product, 
// process, or service by trade name, trade mark, manufacturer,
// or otherwise, does not necessarily constitute or imply its 
// endorsement, recommendation, or favoring by Carnegie Mellon
// University or its Software Engineering Institute.
// NO WARRANTY. THIS CARNEGIE MELLON UNIVERSITY AND SOFTWARE
// ENGINEERING INSTITUTE MATERIAL IS FURNISHED ON AN “AS-IS”
// BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY 
// KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER  
// INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR 
// PURPOSE OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED
// FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT
// MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM
// PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
// This material has been approved for public release and
// unlimited distribution.
// Carnegie Mellon® is registered in the U.S. Patent and 
// Trademark Office by Carnegie Mellon University.
// DM-0001283
//
// What does this program do?
//   It performs schedulability analysis of constrained-deadline sporadic tasks with co-runner dependent
//     execution times?
// 
// How do I install it?
//   Make sure that you have Linux 64 bit. Then install Gurobi. It is free for academic use.
//   Compile the program to link with the Gurobi library as follows:
//       gcc -m64 -g -o schedanalysiscorunner schedanalysiscorunner.c -I/home/bjorn/gurobi/gurobi701/linux64/include -O3 -lm -L/home/bjorn/gurobi/gurobi701/linux64/lib -lgurobi70
//   Now, you have a file schedanalysiscorunner
//		    
// How do I actually run it?
//   Open a console. Then type:
//      schedanalysiscorunner -i taskset.txt -o taskset_results_from_analysis.txt
//   With this command, you tell the tool that it should read the file taskset.txt and perform schedulability analysis and write the output of the analysis to
//     the file taskset_results_from_analysis.txt.
//
// What is the format of the input file?
//   The input file is a text file with numbers and these numbers are not comma separated. 
//   An example of an input file is as follows:
//     1
//     2
//     3
//     1
//     3
//     2
//     508.827494 51.582220
//     1
//     1
//     0.508827
//     0.050000
//     1
//     1 3 1 0.727217
//     2
//     1
//     2
//     2873.485391 1414.746314
//     1
//     1
//     4.000429
//     0.050000
//     1
//     1 3 1 0.616589
//     3
//     2
//     1
//     231.911587 123.257014
//     1
//     1
//     4.074487
//     0.050000
//     2
//     1 1 1 0.965866
//     1 2 1 0.915646
//   
//  The first number in the file is "1". This is the id of the method that is used. So far, this is the only method supported by this tool. So this
//    number should always be "1".
//  The second number in the file is "2". This is the number of processors.
//  The third number in the file is "3". This is the number of tasks.
//  Then follows blocks of parameters for each task.
//  The 4th number in the file is "1". It tells us that the block of parameters that we now describe is for the task with index 1.
//  The 5th number in the file is "3". It tells us that the the task we now describe has priority 3. (a high number means a high priority.)
//  The 6th number in the file is "2". It tells us that the task we now describe is assigned to processor 2. (processors have indices starting with 1.)
//  The 7th and 8th number in the file is "508.827494" and "51.582220" respectively. It is the T parameter and the D parameter.
//  The 9th number in the file is "1". It tells us that the task we now describe has 1 segment.
//  The 10th number in the file is "1". It tells us that the segment we now describe has id 1.
//  The 11th number in the file is "0.508827". It tells us the execution requirement this segment.
//  The 12th number in the file is "0.050000". It tells us the pd parameter of this segment.
//  The 13th number in the file is "1". It tells us the cardinality of the set CO of this segment.
//  The 14th and 15th and 16th and 17th number in the file is "1" and "3" and "1" and "0.727217" respectively. It tells us that for this segment,
//    there is a co-runner set of size 1 and this co-runner set has the members: segment 1 of task 3.
//    It also tells us that if this segment experiences this co-runner set at run-time then the segment has progress factor 0.727217.
//  The file continues with a block for task 2 and then a block for task 3.
//
//  You can learn about the input file format by reading the function "void readtasksetfromfile(char* p)" in this source code file.
//    
// How to use this tool in batch mode?
//   schedanalysiscorunner -g -r -s
//
// How to run many experiments
//   Use the meta mode -m
//
// How to generate a taskset from building blocks of measurements?
//   schedanalysiscorunner -p measurements.txt
//
//  Why is there a "#define COMPILEMSVS 0"?
//    Because a previous version of this software was written so that it could also be compiled under Microsoft Visual Studio. The current version
//    of this software has only been tested for Linux 64 and hence it should have "#define COMPILEMSVS 0". If you want to compile for Microsoft Visual Studio
//    then set "#define COMPILEMSVS 1". And you probably have to spend some more effort to make it work --- not recommend. That has not been tested
//    If you really want to compile this with Microsoft Visual Studio and run it under Windows, here is my advice:
//      Read 40. How do I configure a new Gurobi C++ project with Microsoft Visual Studio 2010? 
//        at http://www.gurobi.com/resources/faqs. It states:
//        It's easiest to modify one of the existing projects in the examples\build subdirectory. However, if you prefer to create a new project from scratch, here are the key steps:
//
//          Under the File menu, select New > Project...; on the Installed Templates panel, select Other Languages > Visual C++ > Win32, then select Win32 Console Application. For illustration, let's call it gurobitest. Press the Finish button to close the Wizard.
//          To add an existing source file:
//              Under Source Files below the project name in the Solution Explorer panel, right click on the initial source file that Visual Studio adds to the project (gurobitest.cpp in our example). Select Remove, then press Delete.
//              Right-click on the project name in the Solution Explorer panel, then select Add > Existing Item..., then choose your C++ source file.
//          Right-click on the project name in the Solution Explorer panel, then select Properties.
//          Under C/C++ / Precompiled Headers / Precompiled Header, select Not Using Precompiled Headers.
//          For 32-bit Gurobi libraries:
//              Under C/C++ / General / Additional Include Directories, add: c:\gurobi550\win32\include
//              Under Linker / General / Additional Library Directories, add: c:\gurobi550\win32\lib
//          For 64-bit Gurobi libraries:
//              Under C/C++ / General / Additional Include Directories, add: c:\gurobi550\win64\include
//              Under Linker / General / Additional Library Directories, add: c:\gurobi550\win64\lib
//              Press the Configuration Manager... button. Under Active solution platform, select New. Set the new platform to x64, and press OK.
//          Under Linker / Input / Additional Dependencies, add gurobi55.lib and gurobi_c++mdd2010.lib
//     
//  What are the limitations of this tool?
//    Look at the paramters
//      #define MAXNTASKS                                 16 // 128 // this needs to be set to 128 when we run the experiments for the table to check scalability
//      #define MAXNPROCESSORS                             8 // 12  // this needs to be set to  12 when we run the experiments for the table to check scalability
//      #define MAXNSEGMENTSPERTASK                        2
//      #define MAXNSEGMENTSINCORUNNERSETSPECIFIED    ((MAXNTASKS-1)*MAXNSEGMENTSPERTASK)
//      #define MAXNCORUNNERSETSSPECIFIED             100000 // 1000000
//      #define MAXNSEGMENTSETREFS                   5000000
//      #define MAXNSEGMENTSETS                       500000 // 5000000
//      #define BUCKETSIZE                              5000
//      #define MAPSIZE                                50000 //  500000
//      #define NSUBSETS                              500000 // 5000000
//    below in this source file. If you run large experiments, you may need to increases these values.
//  
// How fast is this tool?
//   For a system with 8 processors and 10 tasks with each task having 2 segments, the schedulability analysis finishes within 40 seconds.
//  
// When running experiments with -m (meta mode) what should I do:
//   1. unplug the ethernet cable
//   2. disconnect WiFi
//   3. disable networking (in Ubuntu)
//   4. disable getting time from Internet. In Ubuntu, click "System settings". Click "Time and date" Uncheck the box "Automatically from the Internet"

// Advice when running -m
//   Disable the disk cache with
//     sudo hdparm -W0 /dev/sda1
//
// Some status about running time.
//   When running schedanalysiscorunner -m
//   after 4.5 days, it has generated tasksets until meta314 (that is 122 directories of the type metaXXX).
//   Each of meta directory consumes 3.5 GB
//   So in total, it consumed 3.5*122 GB = 420 Gb
//   Note that in order to finish, it needs to run for 200/122=1.6 times longer.
//   That is, in order to finish taskset generation, we could expect it to take 8 days and it would consume 700 GB.
//
// Some history of this source code:
//   As mentioned above, this program can be executed in two different way: (i) meta mode
//   where it generates a large number of taskset (each written to a file) and then analyzes
//   each of them and (ii) normal mode where the tool analyzes a single taskset and the file
//   name of this single taskset is given by the command line. Initially, when the program
//   reads a taskset from file, the file is a text file that is not compressed. This worked fine
//   for normal mode and it also worked for meta mode when the size was small. But then I
//   changed the meta mode so that it generated a large number of files. It took more than
//   2TB and this was more than the hard drive space that I had. Therefore, I rewrote the code
//   so that when it writes a taskset to file, it compresses the taskset and when it reads
//   a taskset from file, it assumes a compressed taskset and it decompresses it.
//   This worked fine for meta mode and this is what I used for the TECS paper.
//   Unfortunately, this had the side effect that now when using the tool in normal mode,
//   the taskset must be in a text file that is compressed. On August 6, 2018, I realized
//   that this makes the tool more difficult to use for software practitioners.
//   For a software practitioner, there are two ways to deal with this. One way is to
//   just accept the tools the way it is and then you have to compress your system.txt
//   file before giving it to this tool. Another way it so make a minor modification of
//   the tool so that you can use the tool in normal mode with uncompressed file. In order
//   to do that, change the function readtasksetfromfile.

#define COMPILEMSVS 0

#if COMPILEMSVS

#else
  #include "gurobi_c.h"  
#endif

// We add these in order to do file I/O like in UNIX. And ceil(..)
#include <stdlib.h>
#include <stdio.h>

#include <time.h> // we add this in order to call the function time( ..)

#if COMPILEMSVS
  #include <io.h>
#endif
#include <fcntl.h>

#if COMPILEMSVS
  #include <process.h>
#endif

#include <math.h>

#include <sys/stat.h> // this is needed for the constant S_IWRITE

#include <string.h>   //  this is needed for strcmp

#if COMPILEMSVS
  #include <direct.h>
#else
  #include <unistd.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>

#define MAX_ITERATOR_IN_BATCH                    100
#define MAXNTASKS                                 16
#define MAXNPROCESSORS                             8
#define MAXNSEGMENTSPERTASK                        2
#define MAXNSEGMENTSINCORUNNERSETSPECIFIED    ((MAXNTASKS-1)*MAXNSEGMENTSPERTASK)
#define MAXNCORUNNERSETSSPECIFIED             115000 // if we use 100000 then it is not enough. 200000 is enough. 150000 is enough. 130000 seems to be enough
#define MAXNSEGMENTSETREFS                    500000
#define MAXNSEGMENTSETS                       500000
#define BUCKETSIZE                               100 // 5000 seems to be enough. 2000 seems to be enough. 500 seems to be enough 
#define MAPSIZE                                50000 
#define NSUBSETS                              500000

// The values below are used when we run experiments to get the table that shows scalability
/*
#define MAX_ITERATOR_IN_BATCH                     10
#define MAXNTASKS                                128
#define MAXNPROCESSORS                            12
#define MAXNSEGMENTSPERTASK                        2
#define MAXNSEGMENTSINCORUNNERSETSPECIFIED    ((MAXNTASKS-1)*MAXNSEGMENTSPERTASK)
#define MAXNCORUNNERSETSSPECIFIED            1000000
#define MAXNSEGMENTSETREFS                   5000000
#define MAXNSEGMENTSETS                      5000000
#define BUCKETSIZE                              5000
#define MAPSIZE                               500000
#define NSUBSETS                             5000000
*/

int enablelogging = 0;
int counterforILPsolver = 0;

int generate_experiments = 0;
int run_experiments = 0;
int generate_statistics = 0;
int metathing = 0;
int producetasksetsfromparts = 0;

char inputfilename[20000]="taskset.txt";
char outputfilename[20000]="taskset_results_from_analysis.txt";
char producetasksetsfrompartsfilename[20000]="measurements.txt";

struct segmentincorunnerset {
  int16_t taskindex;
  int16_t segmentindex;
};

struct corunnersetspecifiedstruct {
  int nsegmentsincorunnerset;
  struct segmentincorunnerset segmentsincorunnerset[MAXNSEGMENTSINCORUNNERSETSPECIFIED+1];  // there is no element in index 0.
  double progresscorunnerset;
};

struct segmentset_ref {
  int index_of_segmentset;
  double pw;
};
struct segmentset {
  int16_t taskindices[MAXNPROCESSORS];
  int16_t segmentindices[MAXNPROCESSORS];
};

struct segment {
  int segid;
  double C;
  double pd;
  int ncorunnersetsspecified;
  struct corunnersetspecifiedstruct* corunnersetsspecified; // there is no element in index 0.
  int partid; // this is only used in the mode "generate from parts"

  int nsegmentsets; // this is used in the new version of analysis (which consumes less memory)
  struct segmentset_ref* segmentset_refs;
  int pos; // this is used to speed up hashing
};

struct task {
  int id;
  int priority;
  int proc;
  double T;
  double D;
  int nsegments;
  struct segment segments[MAXNSEGMENTSPERTASK+1];  // there is no element in index 0.
  int valid;                    // this is computed by the MILP
  double RUB;                     // this is computed by the MILP
  int valid_baselinemethod;      // this is computed by the tbaseline response time calculation
  double RUB_baselinemethod;       // this is computed by the baseline response time calculation
};

int useanalysismethod;
int nprocessors;
int ntasks;
struct task tasks[MAXNTASKS+1];  // there is no element in index 0.

int number_of_segments_on_processor[MAXNPROCESSORS];
int nsegmentsets;
struct segmentset* segmentsets;

struct mapitem {
  int nelements_in_bucket;
  int16_t* taskindices;
  int16_t* segmentindices;
  int32_t* corindices;
};
struct mapitem* mapitems;

int16_t template_localprocessor_taskindices[MAXNPROCESSORS];
int16_t template_localprocessor_segmentindices[MAXNPROCESSORS];

double timerequiredforschedulabilityanalysis_newmethod;  
double timerequiredforschedulabilityanalysis_baselinemethod;  

int nsg = 2; // this means "number of segments per task" and it is used in the meta mode.

struct measurement {
  int tid;
  int cor1;
  int cor2;
  int cor3;
  double max_exec;
  double min_exec;
  double avg_exec;
};

int nmeasurements;
struct measurement measurements[100000];

  GRBenv *env = NULL;
  GRBmodel *model = NULL;
  int error = 0;
  double* sol;
  int nelements_of_constr;
  int* ind;
  double* val;
  int nelements_of_obj;
  double* obj;
  char* vtype;
  int optimstatus;
  double objval;

void dothememoryallocation_for_Gurobi_stuff()
{
  sol    = (double*)             malloc( NSUBSETS * sizeof(double));             if (sol==NULL)   { fprintf(stderr,"malloc failure in dothememoryallocation: sol\n");     exit(-1); }
  ind    = (int*)                malloc( NSUBSETS * sizeof(int));                if (ind==NULL)   { fprintf(stderr,"malloc failure in dothememoryallocation: ind\n");     exit(-1); }
  val    = (double*)             malloc( NSUBSETS * sizeof(double));             if (val==NULL)   { fprintf(stderr,"malloc failure in dothememoryallocation: val\n");     exit(-1); }
  obj    = (double*)             malloc( NSUBSETS * sizeof(double));             if (obj==NULL)   { fprintf(stderr,"malloc failure in dothememoryallocation: obj\n");     exit(-1); }
  vtype  = (char*)               malloc( NSUBSETS * sizeof(char));               if (vtype==NULL) { fprintf(stderr,"malloc failure in dothememoryallocation: vtype\n");   exit(-1); }
}

void freethememory_for_Gurobi_stuff()
{
  free( sol);
  free( ind);
  free( val);
  free( obj);
  free( vtype);
}

void allocate_global_variables() {
  int index; int i; int k;

  mapitems = malloc(sizeof(struct mapitem)*MAPSIZE);
  if (mapitems==NULL) { printf("In allocate_global_variables. Memory allocation failure. mapitems."); exit(-1); }
  for (index=0;index<MAPSIZE;index++) {
    mapitems[index].taskindices    = malloc(sizeof(int)*BUCKETSIZE);
    if (mapitems[index].taskindices==NULL) { printf("In allocate_global_variables. Memory allocation failure. mapitems[index].taskindices."); exit(-1); }
    mapitems[index].segmentindices = malloc(sizeof(int)*BUCKETSIZE);
    if (mapitems[index].segmentindices==NULL) { printf("In allocate_global_variables. Memory allocation failure. mapitems[index].segmentindices."); exit(-1); }
    mapitems[index].corindices     = malloc(sizeof(int)*BUCKETSIZE);    
    if (mapitems[index].corindices==NULL) { printf("In allocate_global_variables. Memory allocation failure. mapitems[index].corindices."); exit(-1); }
  }

  segmentsets = malloc(sizeof(struct segmentset)*MAXNSEGMENTSETS);
  if (segmentsets==NULL) { printf("In allocate_global_variables. Memory allocation failure. segmentsets."); exit(-1); }
  for (i=1;i<=MAXNTASKS;i++) {
    for (k=1;k<=MAXNSEGMENTSPERTASK;k++) {
      tasks[i].segments[k].corunnersetsspecified = malloc((sizeof(struct corunnersetspecifiedstruct))*(MAXNCORUNNERSETSSPECIFIED+1));
      if (tasks[i].segments[k].corunnersetsspecified==NULL) { printf("In allocate_global_variables. Memory allocation failure. corunnersetsspecified."); exit(-1); }
      tasks[i].segments[k].segmentset_refs       = malloc((sizeof(struct segmentset_ref))*(MAXNSEGMENTSETREFS));
      if (tasks[i].segments[k].segmentset_refs==NULL) { printf("In allocate_global_variables. Memory allocation failure. segmentset_refs."); exit(-1); }
    }
  }
  dothememoryallocation_for_Gurobi_stuff();
}

void deallocate_global_variables() {
  int index; int i; int k;
  freethememory_for_Gurobi_stuff();
  for (i=1;i<=MAXNTASKS;i++) {
    for (k=1;k<=MAXNSEGMENTSPERTASK;k++) {
      free( tasks[i].segments[k].corunnersetsspecified);
      free( tasks[i].segments[k].segmentset_refs );
    }
  }
  free(segmentsets);
  for (index=0;index<MAPSIZE;index++) {
    free( mapitems[index].taskindices);
    free( mapitems[index].segmentindices);
    free( mapitems[index].corindices);
  }
  free(mapitems);
}

double mindouble2(double t1, double t2)
{
  if (t1<t2) { return t1; } else { return t2; }
}
double maxdouble2(double t1, double t2)
{
  if (t1>t2) { return t1; } else { return t2; }
}
int minint2(int t1, int t2)
{
  if (t1<t2) { return t1; } else { return t2; }
}
int maxint2(int t1, int t2)
{
  if (t1>t2) { return t1; } else { return t2; }
}

// MS Visual studio does not allow write. So we call this function mywrite that in turn
// calls _write.
int mywrite( int fh, char* tempstr, int len)
{
  #if COMPILEMSVS
    return _write( fh, tempstr, len );
  #else
    return write( fh, tempstr, len );
  #endif
}

int myopen( char* fn, int m1, int m2)
{
  #if COMPILEMSVS
    return _open( fn, m1, m2);
  #else
    return open( fn, m1, m2);
  #endif
}

int myclose( int fh)
{
  #if COMPILEMSVS
    return _close( fh);
  #else
    return close( fh);
  #endif
}

int mychdir( char* p)
{
  #if COMPILEMSVS
    return _chdir( p);
  #else
    return chdir( p);
  #endif
}

int mymakedirectory( char* p)
{
  char tempstr[1000];
  #if COMPILEMSVS
    return mkdir( p, 0700);
  #else
    return mkdir( p, 0700);
  #endif
}

int myrandom()
{
  #if COMPILEMSVS
    return rand();
  #else
    return rand();
  #endif
}

double mydrand48()
{
  int temp; int temp2; double temp3; double temp4;
  #if COMPILEMSVS
    temp = rand();
    temp2 = temp % 2000;
    temp3 = temp2;
    temp4 = (1+temp3)/(2000.0+1.0);
    return temp4;
  #else
    return drand48();
  #endif
}

void mydeletefile( char* p)
{
  char tempstr[1000];
  #if COMPILEMSVS
    sprintf( tempstr, "del %s", p);
    system(tempstr);
  #else
    sprintf( tempstr, "rm %s", p);
    system(tempstr);
  #endif
}

double getutiloftask(int i)
{
  int s; double Ctot;
  Ctot = 0.0;
  for (s=1;s<=tasks[i].nsegments;s++) {
    Ctot = Ctot + tasks[i].segments[s].C;  
  }
  return Ctot/tasks[i].T;
}

double getutilofprocessor(int p)
{
  int i; double usum;
  usum = 0.0;
  for (i=1;i<=ntasks;i++) {
    if (tasks[i].proc!=-1) {
      if (tasks[i].proc==p) {
        usum = usum + getutiloftask(i);
      }
    }
  }
  return usum;
}

int istasksetguaranteedtobeschedulable()
{
  int i;
  for (i=1;i<=ntasks;i++) {
    if (!tasks[i].valid) {
      return 0;
    } else {
      if (tasks[i].RUB>tasks[i].D) {
        return 0;
      }
    }
  }
  return 1;
}

int istasksetguaranteedtobeschedulable_baselinemethod()
{
  int i;
  for (i=1;i<=ntasks;i++) {
    if (!tasks[i].valid_baselinemethod) {
      return 0;
    } else {
      if (tasks[i].RUB_baselinemethod>tasks[i].D) {
        return 0;
      }
    }
  }
  return 1;
}

void printtask(FILE* myfile, int i)
{
  int myiteratorvar; int myiteratorvar2; int myiteratorvar3;
  fprintf(myfile,"tasks[%d].id=%d\n",         i, tasks[i].id );
  fprintf(myfile,"tasks[%d].priority=%d\n",   i, tasks[i].priority );
  fprintf(myfile,"tasks[%d].proc=%d\n",       i, tasks[i].proc );
  fprintf(myfile,"tasks[%d].T=%lf ",          i, tasks[i].T );
  fprintf(myfile,"tasks[%d].D=%lf\n",         i, tasks[i].D );
  fprintf(myfile,"task[%d].nsegments=%d\n",  i, tasks[i].nsegments );
  for (myiteratorvar=1;myiteratorvar<=tasks[i].nsegments;myiteratorvar++) {
    fprintf(myfile,"tasks[%d].segments[%d].segid=%d\n",                   i,myiteratorvar,tasks[i].segments[myiteratorvar].segid );
    fprintf(myfile,"tasks[%d].segments[%d].C=%lf\n",                      i,myiteratorvar,tasks[i].segments[myiteratorvar].C );
    fprintf(myfile,"tasks[%d].segments[%d].pd=%lf\n",                     i,myiteratorvar,tasks[i].segments[myiteratorvar].pd );
    fprintf(myfile,"tasks[%d].segments[%d].ncorunnersetsspecified=%d\n",  i,myiteratorvar,tasks[i].segments[myiteratorvar].ncorunnersetsspecified );
    for (myiteratorvar2=1;myiteratorvar2<=tasks[i].segments[myiteratorvar].ncorunnersetsspecified;myiteratorvar2++) {
      fprintf(myfile,"tasks[%d].segments[%d].corunnersetsspecified[%d].nsegmentsincorunnerset=%d",
        i,myiteratorvar,myiteratorvar2,tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].nsegmentsincorunnerset );
      for (myiteratorvar3=1;myiteratorvar3<=tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].nsegmentsincorunnerset;myiteratorvar3++) {
        fprintf(myfile,"tasks[%d].segments[%d].corunnersetspecified[%d].segmentsincorunnerset[%d],taskindex=%hd", 
          i,myiteratorvar,myiteratorvar2,myiteratorvar3,tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].segmentsincorunnerset[myiteratorvar3].taskindex );
        fprintf(myfile,"tasks[%d].segments[%d].corunnersetspecified[%d].segmentsincorunnerset[%d].segmentindex=%hd",
          i,myiteratorvar,myiteratorvar2,myiteratorvar3,tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].segmentsincorunnerset[myiteratorvar3].segmentindex );
      }
      fprintf(myfile,"tasks[%d].segments[%d].corunnersetspecified[%d].progresscorunnerset=%lf\n",
        i,myiteratorvar,myiteratorvar2,tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].progresscorunnerset );
    }
  }
  fprintf( myfile, "\n  valid = %d\n", tasks[i].valid);
  fprintf( myfile, "\n  RUB = %lf\n", tasks[i].RUB);
  fprintf( myfile, "\n");
}

void printtasksinternal(FILE* myfile)
{
  int i;
  fprintf( myfile, "useanalysismethod = %d\n",  useanalysismethod);
  fprintf( myfile, "nprocessors = %d\n",  nprocessors);
  fprintf( myfile, "ntasks = %d\n",  ntasks);
  for (i=1;i<=ntasks;i++) {
    printtask( myfile, i);
  }
}

void printtasks()
{
  printtasksinternal( stdout);
}

void printtaskstooutputfile()
{
  FILE* myfile;
  myfile = fopen( outputfilename, "w");
  printtasksinternal( myfile);
  fclose( myfile);
}

void readtasksetfromfile_task(FILE* myfile, int i)
{
  int myiteratorvar; int myiteratorvar2; int myiteratorvar3;
  fscanf(myfile,"%d",   &(tasks[i].id) );
  fscanf(myfile,"%d",   &(tasks[i].priority) );
  fscanf(myfile,"%d",   &(tasks[i].proc) );
  fscanf(myfile,"%lf",  &(tasks[i].T) );
  fscanf(myfile,"%lf",  &(tasks[i].D) );
  fscanf(myfile,"%d",   &(tasks[i].nsegments) );
  for (myiteratorvar=1;myiteratorvar<=tasks[i].nsegments;myiteratorvar++) {
    fscanf(myfile,"%d",  &(tasks[i].segments[myiteratorvar].segid) );
    fscanf(myfile,"%lf", &(tasks[i].segments[myiteratorvar].C) );
    fscanf(myfile,"%lf", &(tasks[i].segments[myiteratorvar].pd) );
    fscanf(myfile,"%d",  &(tasks[i].segments[myiteratorvar].ncorunnersetsspecified) );
    for (myiteratorvar2=1;myiteratorvar2<=tasks[i].segments[myiteratorvar].ncorunnersetsspecified;myiteratorvar2++) {
      fscanf(myfile,"%d",  &(tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].nsegmentsincorunnerset) );
      for (myiteratorvar3=1;myiteratorvar3<=tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].nsegmentsincorunnerset;myiteratorvar3++) {
        fscanf(myfile,"%hd",  &(tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].segmentsincorunnerset[myiteratorvar3].taskindex) );
        fscanf(myfile,"%hd",  &(tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].segmentsincorunnerset[myiteratorvar3].segmentindex) );
      }
      fscanf(myfile,"%lf",  &(tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].progresscorunnerset) );
    }
  }  
}

void readtasksetfromfile_internal(char* fn)
{
  int temp; FILE* myfile; int i;
  myfile = fopen( fn, "rt");
  if (myfile==NULL) {
    printf("Error opening file in function readtasksetfromfile. fn=%s\n", fn);
    scanf("%d", &temp);
    exit(0);
  }
  fscanf(myfile, "%d", &useanalysismethod);
  fscanf(myfile, "%d", &nprocessors);
  fscanf(myfile, "%d", &ntasks);
  printf("ntasks = %d\n", ntasks);
  for (i=1;i<=ntasks;i++) {
    readtasksetfromfile_task(myfile,i);
  }
  fclose( myfile);
}

#define COPYINGBUFSIZE 1048576
char buf[COPYINGBUFSIZE];

void mycopyfile(char* fromfn,char* tofn) {
  int count_read; int count_written;
  int fdin; int fdout;
  fdin  = open(fromfn,O_RDONLY,S_IRUSR);
  if (fdin==-1)  { printf("Error opening infile  in mycopyfile. fromfn=%s tofn=%s\n", fromfn, tofn); exit(-1); }
  fdout = open(tofn, O_CREAT | O_WRONLY,S_IRUSR | S_IWUSR);
  if (fdout==-1) { printf("Error opening outfile in mycopyfile. fromfn=%s tofn=%s\n", fromfn, tofn); exit(-1); }
  count_read = read(fdin,buf,COPYINGBUFSIZE);
  if (count_read==-1) { printf("Error reading infile in mycopyfile. fromfn=%s tofn=%s\n", fromfn, tofn); exit(-1); }
  while (count_read==COPYINGBUFSIZE) {
    count_written=write(fdout,buf,count_read);
    if (count_written==-1) { printf("Error writing outfile in mycopyfile. fromfn=%s tofn=%s\n", fromfn, tofn); exit(-1); }
    count_read = read(fdin,buf,COPYINGBUFSIZE);
    if (count_read==-1) { printf("Error reading infile in mycopyfile. fromfn=%s tofn=%s\n", fromfn, tofn); exit(-1); }
  }
  if (count_read>0) {
    count_written=write(fdout,buf,count_read);
    if (count_written==-1) { printf("Error writing outfile in mycopyfile. fromfn=%s tofn=%s\n", fromfn, tofn); exit(-1); }
  }
  close( fdin); close( fdout);
} 

void readtasksetfromfile(char* fn) {
  char command[500];
  char fromfn[500];
  char tofngz[500];
  char tofn[500];
  sprintf(fromfn, "%s.gz",fn);
  sprintf(tofngz, "/tmp/apa.gz");
  sprintf(tofn,   "/tmp/apa");
  remove(tofngz);
  remove(tofn);
  mycopyfile(fromfn,tofngz); 
  sprintf(command, "sync");
  system(command);
  sprintf(command, "gunzip %s", tofngz);
  system(command);
  readtasksetfromfile_internal(tofn);
}

void writetasksettofile_task(FILE* myfile, int i)
{
  int myiteratorvar; int myiteratorvar2; int myiteratorvar3;
  fprintf(myfile,"%d\n",   tasks[i].id );
  fprintf(myfile,"%d\n",   tasks[i].priority );
  fprintf(myfile,"%d\n",   tasks[i].proc );
  fprintf(myfile,"%lf ",  tasks[i].T );
  fprintf(myfile,"%lf\n",  tasks[i].D );
  fprintf(myfile,"%d\n", tasks[i].nsegments );
  for (myiteratorvar=1;myiteratorvar<=tasks[i].nsegments;myiteratorvar++) {
    fprintf(myfile,"%d\n",  tasks[i].segments[myiteratorvar].segid );
    fprintf(myfile,"%lf\n", tasks[i].segments[myiteratorvar].C );
    fprintf(myfile,"%lf\n", tasks[i].segments[myiteratorvar].pd );
    fprintf(myfile,"%d\n",  tasks[i].segments[myiteratorvar].ncorunnersetsspecified );
    for (myiteratorvar2=1;myiteratorvar2<=tasks[i].segments[myiteratorvar].ncorunnersetsspecified;myiteratorvar2++) {
      fprintf(myfile,"%d ", tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].nsegmentsincorunnerset );
      for (myiteratorvar3=1;myiteratorvar3<=tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].nsegmentsincorunnerset;myiteratorvar3++) {
        fprintf(myfile,"%hd ", tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].segmentsincorunnerset[myiteratorvar3].taskindex );
        fprintf(myfile,"%hd ", tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].segmentsincorunnerset[myiteratorvar3].segmentindex );
      }
      fprintf(myfile,"%lf\n", tasks[i].segments[myiteratorvar].corunnersetsspecified[myiteratorvar2].progresscorunnerset );
    }
  }
}

void writetasksettofile_internal(char* fn)
{
  int temp; FILE* myfile; int i;
  char tempstring[20000];
  myfile = fopen( fn, "w");
  if (myfile==NULL) {
    printf("Error opening file in function writetasksettofile. fn=%s\n", fn);
    scanf("%d", &temp);
    exit(0);
  }
  fprintf(myfile, "%d\n", useanalysismethod);
  fprintf(myfile, "%d\n", nprocessors);
  fprintf(myfile, "%d\n", ntasks);
  for (i=1;i<=ntasks;i++) {
    writetasksettofile_task( myfile, i);
  }
  fclose( myfile);
}

void writetasksettofile(char* fn) {
  char command[2000];
  writetasksettofile_internal(fn);
  sprintf(command, "sync");
  system(command);
  sprintf(command, "gzip %s", fn);
  system(command);
}

void writeutilizations(FILE* myfile)
{
  int i; int p;
  for (i=1;i<=ntasks;i++) {
    fprintf(myfile,"task %d has utilization %lf\n", i, getutiloftask(i) );
  }
  for (p=1;p<=nprocessors;p++) {
    fprintf(myfile,"processor %d has utilization %lf\n", p, getutilofprocessor(p) );
  }
}

void writeresponsetimestofile(char* fn)
{
  FILE* myfile;
  int i; int temp;
  myfile = fopen( fn, "w");
  if (myfile==NULL) {
    printf("Error opening file CCC\n");
    scanf("%d", &temp);
    exit(0);
  }
  fprintf(myfile,"%d\n", istasksetguaranteedtobeschedulable());
  fprintf(myfile,"%lf\n", timerequiredforschedulabilityanalysis_newmethod);
  fprintf(myfile,"%d\n", istasksetguaranteedtobeschedulable_baselinemethod());
  fprintf(myfile,"%lf\n", timerequiredforschedulabilityanalysis_baselinemethod);
  for (i=1;i<=ntasks;i++) {
    fprintf(myfile,"task with id=%d priority=%d proc=%d has valid=%d RUB=%lf valid_baselinemethod=%d RUBbaselinemethod=%lf\n",
            tasks[i].id, tasks[i].priority, tasks[i].proc, tasks[i].valid, tasks[i].RUB, tasks[i].valid_baselinemethod, tasks[i].RUB_baselinemethod);
  }
  writeutilizations(myfile);
  fclose( myfile);
}

int is_in_hepx( int i, int j)
{
  if ((j!=i) && (tasks[j].priority >= tasks[i].priority) && (tasks[j].proc==tasks[i].proc))
    return 1;
  else
    return 0;  
}

int is_in_hep( int i, int j)
{
  if ((tasks[j].priority >= tasks[i].priority) && (tasks[j].proc==tasks[i].proc))
    return 1;
  else
    return 0;  
}

int is_in_top( int i, int j)
{
  if (tasks[j].proc!=tasks[i].proc)
    return 1;
  else
    return 0;  
}


int getnheptasks( int iprime)
{
  int nheptasks; int iprimeprime;
  nheptasks = 0;
  for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
    if (is_in_hep( iprime, iprimeprime)) {
      nheptasks = nheptasks + 1;
    }
  }
  return nheptasks;
}

int isinTS(int i,int iprime) {
  if (tasks[iprime].proc == tasks[i].proc) {
    if (is_in_hep( i, iprime)) {
      return 1;
    } else {
      return 0;
    }
  } else {
    return 1;
  }
}

void setup_number_of_segments_on_processor() {
  int pprime; int iprime; int kprime; int localpos;
  for (pprime=1;pprime<=nprocessors;pprime++) {
    number_of_segments_on_processor[pprime-1] = 0;
    for (iprime=1;iprime<=ntasks;iprime++) {
      if (tasks[iprime].proc==pprime) {
        number_of_segments_on_processor[pprime-1] = number_of_segments_on_processor[pprime-1] + tasks[iprime].nsegments;
      }
    }
  }

  for (pprime=1;pprime<=nprocessors;pprime++) {
    localpos = 1;
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
        if (tasks[iprime].proc==pprime) {
          tasks[ iprime ].segments[ kprime ].pos = localpos;
          localpos = localpos + 1;
        }
      }
    }
  }
}

// i is the task we are analyzing
void fill_segmentsets_internal(int i, int p) {
  int pprime; int allempty; int temp; int iprime; int kprime;
  if (p>nprocessors) {
    allempty = 1;
    for (pprime=1;pprime<=nprocessors;pprime++) {
      allempty = allempty && (template_localprocessor_taskindices[pprime-1]==-1) && (template_localprocessor_segmentindices[pprime-1]==-1);
    }
    if (!allempty) {
      for (pprime=1;pprime<=nprocessors;pprime++) {
        segmentsets[nsegmentsets].taskindices[pprime-1]    = template_localprocessor_taskindices[pprime-1];
        segmentsets[nsegmentsets].segmentindices[pprime-1] = template_localprocessor_segmentindices[pprime-1];
      }
      nsegmentsets = nsegmentsets + 1;
      if (nsegmentsets>MAXNSEGMENTSETS) { printf("In fill_segmentsets_internal: out of memory.\n"); exit(0); }
    }
  } else {
    if (tasks[i].proc!=p) {
      template_localprocessor_taskindices[ p-1] = -1;
      template_localprocessor_segmentindices[ p-1] = -1;
      fill_segmentsets_internal( i, p+1);
    }
    for (iprime=1;iprime<=ntasks;iprime++) {
      for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
        if ( (tasks[iprime].proc ==p) && (isinTS(i,iprime)) ) {
          if (tasks[iprime].proc == tasks[i].proc) {
            if (is_in_hep( i, iprime)) {
              template_localprocessor_taskindices[ p-1]    = iprime;
              template_localprocessor_segmentindices[ p-1] = kprime;
              fill_segmentsets_internal( i, p+1);
            }
          } else {
            template_localprocessor_taskindices[ p-1]    = iprime;
            template_localprocessor_segmentindices[ p-1] = kprime;
            fill_segmentsets_internal( i, p+1);
          }
        } 
      }
    }
  }
}

// i is the task we are analyzing
void fill_segmentsets(int i) {
  nsegmentsets = 0;
  fill_segmentsets_internal(i, 1); 
}

void form_template(int iprime, int kprime, int corindex) {
  int pprime; int corsegindex; int iprimeprime; int kprimeprime;
  for (pprime=1;pprime<=nprocessors;pprime++) {
    template_localprocessor_taskindices[ pprime-1]    = -1;
    template_localprocessor_segmentindices[ pprime-1] = -1;
  }
  template_localprocessor_taskindices[    tasks[iprime].proc-1] = iprime;
  template_localprocessor_segmentindices[ tasks[iprime].proc-1] = kprime;
  for (corsegindex=1;corsegindex<=tasks[iprime].segments[kprime].corunnersetsspecified[corindex].nsegmentsincorunnerset;corsegindex++) {
    iprimeprime = tasks[iprime].segments[kprime].corunnersetsspecified[corindex].segmentsincorunnerset[corsegindex].taskindex;
    kprimeprime = tasks[iprime].segments[kprime].corunnersetsspecified[corindex].segmentsincorunnerset[corsegindex].segmentindex;
    template_localprocessor_taskindices[    tasks[iprimeprime].proc-1] = iprimeprime;
    template_localprocessor_segmentindices[ tasks[iprimeprime].proc-1] = kprimeprime;
  }
}

int compute_hash_based_on_template() {
  int sum; int pprime; int scalefactor; int localpos;
  sum = 0;
  scalefactor = 1;
  for (pprime=1;pprime<=nprocessors;pprime++) {
    if ((template_localprocessor_taskindices[ pprime-1]==-1) && (template_localprocessor_segmentindices[ pprime-1]==-1)) {
      localpos = 0;
    } else {
      localpos = tasks[ template_localprocessor_taskindices[ pprime-1] ].segments[ template_localprocessor_segmentindices[ pprime-1] ].pos;
    }
    sum = sum + localpos*scalefactor;
    scalefactor = scalefactor * (1+number_of_segments_on_processor[pprime-1]);
  }
  return (sum % MAPSIZE);
}

int template_localprocessorindices_matches_segmentset(int segmentsetindex) {
  int match; int pprime;
  match = 1;
  for (pprime=1;pprime<=nprocessors;pprime++) {
    match = match && (template_localprocessor_taskindices[pprime-1]    == segmentsets[segmentsetindex].taskindices[pprime-1] ) && 
                     (template_localprocessor_segmentindices[pprime-1] == segmentsets[segmentsetindex].segmentindices[pprime-1] );
  }
  return match;
}

double getpw(int iprime,int kprime, int segmentsetindex) {
  int pprime; int bucketindex; int match; int iterator; int corindex;
  match = 1;
  for (pprime=1;pprime<=nprocessors;pprime++) {
    if (pprime!=tasks[iprime].proc) {
      match = match && (segmentsets[segmentsetindex].taskindices[pprime-1]==-1) &&
                       (segmentsets[segmentsetindex].segmentindices[pprime-1]==-1);
    }
  }
  if (match) { return 1.0; }
  for (pprime=1;pprime<=nprocessors;pprime++) {
    template_localprocessor_taskindices[pprime-1]    = segmentsets[segmentsetindex].taskindices[pprime-1];
    template_localprocessor_segmentindices[pprime-1] = segmentsets[segmentsetindex].segmentindices[pprime-1];
  }
  bucketindex = compute_hash_based_on_template();
  for (iterator=0;iterator<mapitems[bucketindex].nelements_in_bucket;iterator++) {
    if ( (mapitems[bucketindex].taskindices[iterator]    == iprime) &&
         (mapitems[bucketindex].segmentindices[iterator] == kprime) ) {
      corindex = mapitems[bucketindex].corindices[iterator];
      form_template(iprime,kprime,corindex);
      if (template_localprocessorindices_matches_segmentset(segmentsetindex)) {
        return tasks[iprime].segments[kprime].corunnersetsspecified[corindex].progresscorunnerset;
      }
    }
  }
  return tasks[iprime].segments[kprime].pd;  
}

void fill_segmentsets_that_includes_segment(int iprime,int kprime) {
  int segmentsetindex; int loc; int local_taskindex; int local_segmentindex;
  tasks[iprime].segments[kprime].nsegmentsets = 0;
  for (segmentsetindex=0;segmentsetindex<nsegmentsets;segmentsetindex++) {
    local_taskindex                  = segmentsets[segmentsetindex].taskindices[tasks[iprime].proc-1]; 
    local_segmentindex               = segmentsets[segmentsetindex].segmentindices[tasks[iprime].proc-1];
    if ((local_taskindex == iprime) && (local_segmentindex == kprime)) {
      tasks[iprime].segments[kprime].segmentset_refs[ tasks[iprime].segments[kprime].nsegmentsets ].index_of_segmentset = segmentsetindex;
      tasks[iprime].segments[kprime].segmentset_refs[ tasks[iprime].segments[kprime].nsegmentsets ].pw = getpw( iprime, kprime, segmentsetindex);
      tasks[iprime].segments[kprime].nsegmentsets = tasks[iprime].segments[kprime].nsegmentsets + 1;
      if (tasks[iprime].segments[kprime].nsegmentsets>MAXNSEGMENTSETREFS ) { printf("In fill_segmentsets_that_includes_segment: out of memory.\n"); exit(0); }
    }
  }
}

void setup_map(int i) {
  int iprime; int kprime; int corindex; int bucketindex;
  for (bucketindex=0;bucketindex<MAPSIZE;bucketindex++) {
    mapitems[bucketindex].nelements_in_bucket = 0;
  }
  for (iprime=1;iprime<=ntasks;iprime++) {
    for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
      for (corindex=1;corindex<=tasks[iprime].segments[kprime].ncorunnersetsspecified;corindex++) {
        if (isinTS(i,iprime)) {
          form_template(iprime, kprime, corindex);
          bucketindex = compute_hash_based_on_template();
          mapitems[bucketindex].taskindices[    mapitems[bucketindex].nelements_in_bucket ] = iprime;
          mapitems[bucketindex].segmentindices[ mapitems[bucketindex].nelements_in_bucket ] = kprime;
          mapitems[bucketindex].corindices[     mapitems[bucketindex].nelements_in_bucket ] = corindex;
          if (mapitems[bucketindex].nelements_in_bucket>=BUCKETSIZE) { printf("In setup_map: out of memory.\n"); exit(0); }
          mapitems[bucketindex].nelements_in_bucket = mapitems[bucketindex].nelements_in_bucket + 1;
        }
      }     
    }
  }
}

double getworstpwforthissegment(int j, int k) {
  int index_lowest_so_far; double value_lowest_so_far; int segmentsetindex; double v;
  index_lowest_so_far = -1;
  for (segmentsetindex=0;segmentsetindex<nsegmentsets;segmentsetindex++) {
    v = getpw(j,k, segmentsetindex);
    if (index_lowest_so_far==-1) {
      index_lowest_so_far = segmentsetindex;
      value_lowest_so_far = v;
    } else {
      if (v<value_lowest_so_far) {
        index_lowest_so_far = segmentsetindex;
        value_lowest_so_far = v;
      }
    }  
  }
  if (index_lowest_so_far==-1) {
    printf("Error in getworstpwforthissegment\n"); exit(0);
  }
  return value_lowest_so_far;
}

double xUB(int iprime, int kprime, double t)
{
  int allnonzero; double LST;
  double consideredinterval; int kprimeprime; int nwholejobs; double sum;
  allnonzero = 1;
  for (kprimeprime=1;kprimeprime<=kprime-1;kprimeprime++) {
    allnonzero = allnonzero && (getworstpwforthissegment(iprime, kprimeprime)>0);
  }
  if ((getnheptasks(iprime)==1) && (allnonzero)) {
    LST = 0;
    for (kprimeprime=1;kprimeprime<=kprime-1;kprimeprime++) {
      LST = LST + tasks[iprime].segments[kprimeprime].C / getworstpwforthissegment(iprime, kprimeprime);
    }
    consideredinterval = t+mindouble2(tasks[iprime].D,LST);
    nwholejobs = ceil( consideredinterval / tasks[iprime].T);
    sum = nwholejobs*tasks[iprime].segments[kprime].C;
    return sum;
  } else {
    consideredinterval = t + tasks[iprime].D;
    nwholejobs = ceil( consideredinterval / tasks[iprime].T);
    sum = nwholejobs*tasks[iprime].segments[kprime].C;
    return sum;
  }
}

void fillobj_for_objective_function() {
  int temp;
  nelements_of_obj = nsegmentsets;
  if (nelements_of_obj>NSUBSETS) { printf("In fillobj_for_objective_function. Not enough memory\n"); exit(-1); }
  for (temp=0;temp<nsegmentsets;temp++) {
    obj[temp] = 1.0;
    vtype[temp] = GRB_CONTINUOUS;
  }
}

void fillindandval_for_constraintsexec(int iprime, int kprime) {
  int tempindex; int tempindex2;
  nelements_of_constr = 0;
  for (tempindex=0;tempindex<tasks[iprime].segments[kprime].nsegmentsets;tempindex++) {
    ind[nelements_of_constr] = tasks[iprime].segments[kprime].segmentset_refs[ tempindex].index_of_segmentset;
    val[nelements_of_constr] = tasks[iprime].segments[kprime].segmentset_refs[ tempindex].pw;
    nelements_of_constr = nelements_of_constr + 1;
    if (nelements_of_constr>NSUBSETS) { printf("In fillindandval_for_constraintsexec. Not enough memory\n"); exit(-1); }
  }
}

double gurobi_run_time;

// this optimization problem is always feasible so we do not need to return feasible/infeasible.
// but we return it anyway, for historical reasons. It should return feas=true
// this function is req_lp in the paper "Schedulability Analysis of Tasks with Co-Runner Dependent Execution Times"
void req_basic( int i, double t, int* feas, double* value)
{
  int iprime; int kprime; double rhs; char miplogfn[20000]; char mipfn[20000]; char mipfnlp[20000];
  counterforILPsolver = counterforILPsolver + 1;
  sprintf(miplogfn,"mip%d.log", counterforILPsolver);
  sprintf(mipfn,"mip%d", counterforILPsolver);
  sprintf(mipfnlp,"mip%d.lp", counterforILPsolver);

  // dothememoryallocation();

  // if (enablelogging) {
    error = GRBloadenv( &env, miplogfn);
  // } else {
  //  error = GRBloadenv( &env, NULL);
  // }
  if (error || env == NULL) {
    fprintf(stderr, "Error: could not create environment. errorcode = %d.\n", error);
    exit(0);
  }
  // error = GRBsetintparam(env, GRB_INT_PAR_METHOD, 1); // method = 1 means dual simplex
  // if (error) goto QUIT;
  error = GRBnewmodel( env, &model, mipfn, 0, NULL, NULL, NULL, NULL, NULL );
  if (error) goto QUIT;
  fillobj_for_objective_function(i);
  error = GRBaddvars( model, nelements_of_obj, 0, NULL, NULL, NULL, obj, NULL, NULL, vtype, NULL);
  if (error) goto QUIT;
  error = GRBsetintattr( model, GRB_INT_ATTR_MODELSENSE, GRB_MAXIMIZE);
  if (error) goto QUIT;
  error = GRBupdatemodel( model);
  if (error) goto QUIT;
  for (iprime=1;iprime<=ntasks;iprime++) {
    for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
      if (is_in_hep(i,iprime)) {
        rhs = ceil( t/tasks[iprime].T) * tasks[iprime].segments[kprime].C;
        fillindandval_for_constraintsexec(iprime, kprime);
        error = GRBaddconstr( model, nelements_of_constr, ind, val, GRB_LESS_EQUAL, rhs, NULL );
        if (error) goto QUIT;
      }
    }
  }
  for (iprime=1;iprime<=ntasks;iprime++) {
    for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
      if (is_in_top(i,iprime)) {
        rhs = xUB(iprime, kprime, t);
        fillindandval_for_constraintsexec(iprime, kprime);
        error = GRBaddconstr( model, nelements_of_constr, ind, val, GRB_LESS_EQUAL, rhs, NULL );
        if (error) goto QUIT;
      }
    }
  }
  error = GRBupdatemodel( model);
  if (error) goto QUIT;
  error = GRBoptimize(model);
  if (error) goto QUIT;
  error = GRBupdatemodel( model);
  if (error) goto QUIT;
  if (enablelogging) {
    error = GRBwrite( model, mipfnlp);
    if (error) goto QUIT;
  }
  error = GRBgetintattr( model, GRB_INT_ATTR_STATUS, &optimstatus);
  if (error) goto QUIT;
  error = GRBgetdblattr( model, GRB_DBL_ATTR_OBJVAL, &objval);
  if (error) goto QUIT;
  error = GRBgetdblattrarray( model, GRB_DBL_ATTR_X, 0, nelements_of_obj, sol);
  if (error) goto QUIT;
  error = GRBgetdblattr( model, GRB_DBL_ATTR_RUNTIME, &gurobi_run_time);
  if (error) goto QUIT;

  *feas = 0;
  printf("\nOptimization complete\n");
  if (optimstatus == GRB_OPTIMAL) {
    printf("Optimal objective: %.4e\n", objval);
    *feas = 1;
    *value = objval;
  } else {
    printf("Did not get an objective.\n");
  }
QUIT:
  if (error) {
    printf("ERROR: %s\n", GRBgeterrormsg(env) );
    exit(1);
   }
   GRBfreemodel( model);
   GRBfreeenv( env);

   // freethememory();
}

double compute_lb_of_worstcase_response_time(int i)
{
  double temp; int k;
  temp = 0.0;
  for (k=1;k<=tasks[i].nsegments;k++) {
    temp = temp + tasks[i].segments[k].C;
  }
  return temp;
}

#if COMPILEMSVS
unsigned __int128 diff_us_timeval(struct timeval *x, struct timeval *y)
{
  unsigned __int128 amillion = 1000000;
  unsigned __int128 u = ((x->tv_sec * amillion) + x->tv_usec);
  unsigned __int128 v = ((y->tv_sec * amillion) + y->tv_usec);
  return u-v;
}
double diff_s_timeval(struct timeval *x, struct timeval *y)
{
  unsigned __int128 amillion = 1000000;
  unsigned __int128 t;
  unsigned __int128 tsec;
  unsigned __int128 tusec;
  double t_as_double_secondpart;
  double t_as_double_usecondpart;
  double t_as_double;
  t = diff_us_timeval( x, y);
  tsec = t / amillion;
  tusec =  t % amillion; 
  t_as_double_secondpart = tsec;
  t_as_double_usecondpart = tusec;
  t_as_double_usecondpart = t_as_double_usecondpart / amillion;
  t_as_double = t_as_double_secondpart + t_as_double_usecondpart; 
  return t_as_double;
}
#else
unsigned long long diff_ns_timespec(struct timespec *x, struct timespec *y) {
  unsigned long long abillion = 1000000000;
  unsigned long long u;
  u = x->tv_sec;
  u = u * abillion;
  u = u + x->tv_nsec;

  unsigned long long v;
  v = y->tv_sec;
  v = v * abillion;
  v = v + y->tv_nsec;
  return u-v;
}
double diff_s_timespec (struct timespec *x, struct timespec *y)
{
  unsigned long long abillion = 1000000000;
  unsigned long long t;
  unsigned long long tsec;
  unsigned long long tnsec;
  double t_as_double_secondpart;
  double t_as_double_usecondpart;
  double t_as_double;
  t = diff_ns_timespec( x, y);
  tsec = t / abillion;
  tnsec =  t % abillion; 
  t_as_double_secondpart = tsec;
  t_as_double_usecondpart = tnsec;
  t_as_double_usecondpart = t_as_double_usecondpart / abillion;
  t_as_double = t_as_double_secondpart + t_as_double_usecondpart; 
  return t_as_double;
}
#endif

#if COMPILEMSVS

#define CLOCK_REALTIME 0
LARGE_INTEGER getFILETIMEoffset()
{
    SYSTEMTIME s;
    FILETIME f;
    LARGE_INTEGER t;
    s.wYear = 1970;
    s.wMonth = 1;
    s.wDay = 1;
    s.wHour = 0;
    s.wMinute = 0;
    s.wSecond = 0;
    s.wMilliseconds = 0;
    SystemTimeToFileTime(&s, &f);
    t.QuadPart = f.dwHighDateTime;
    t.QuadPart <<= 32;
    t.QuadPart |= f.dwLowDateTime;
    return (t);
}
 
int my_clock_gettime(int X, struct timeval *tv)
{
  LARGE_INTEGER           t;
  FILETIME            f;
  double                  microseconds;
  static LARGE_INTEGER    offset;
  static double           frequencyToMicroseconds;
  static int              initialized = 0;
  static BOOL             usePerformanceCounter = 0;
  if (!initialized) {
    LARGE_INTEGER performanceFrequency;
    initialized = 1;
    usePerformanceCounter = QueryPerformanceFrequency(&performanceFrequency);
    if (usePerformanceCounter) {
      QueryPerformanceCounter(&offset);
      frequencyToMicroseconds = (double)performanceFrequency.QuadPart / 1000000.;
    } else {
      offset = getFILETIMEoffset();
      frequencyToMicroseconds = 10.;
    }
  }
  if (usePerformanceCounter) { QueryPerformanceCounter(&t); }
  else {
    GetSystemTimeAsFileTime(&f);
    t.QuadPart = f.dwHighDateTime;
    t.QuadPart <<= 32;
    t.QuadPart |= f.dwLowDateTime;
  }
  t.QuadPart -= offset.QuadPart;
  microseconds = (double)t.QuadPart / frequencyToMicroseconds;
  t.QuadPart = microseconds;
  tv->tv_sec = t.QuadPart / 1000000;
  tv->tv_usec = t.QuadPart % 1000000;
  return (0);
}
#endif

void printmapitems(int fromindex, int toindex, int np) {
  int temp; int temp2;
  for (temp=fromindex;temp<=toindex;temp++) {
    printf("mapitems[%d].nelements_in_bucket  = %d\n",  temp, mapitems[temp].nelements_in_bucket );
    for (temp2=0;temp2<np;temp2++) {
      printf("mapitems[%d].taskindices[     %d ] = %d\n", temp, temp2, mapitems[temp].taskindices[ temp2 ]    );
      printf("mapitems[%d].segmentindices[  %d ] = %d\n", temp, temp2, mapitems[temp].segmentindices[ temp2 ] );
      printf("mapitems[%d].corindices[      %d ] = %d\n", temp, temp2, mapitems[temp].corindices[  temp2 ]    );
    }
  }
}

void do_setup_data_structures(int i) {
  int iprime; int kprime;
  setup_number_of_segments_on_processor();
  fill_segmentsets(i);   
  setup_map(i);
  for (iprime=1;iprime<=ntasks;iprime++) {
    for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
      if (isinTS( i, iprime)) {
        fill_segmentsets_that_includes_segment(iprime,kprime);
      }
    }
  }
}

int determineschedulabilityandcomputeresponsetimes_with_reqlpmethod()
{
  int i; double t; double newt; int feas; int convg; int dmiss; int allvalid; FILE* foutclockinfo;
  int iprime; int kprime;
  #if COMPILEMSVS
    struct timeval mybegin;
    struct timeval myend;
  #else
    struct timespec mybegin;
    struct timespec myend;
  #endif
  int status_clock_gettime_begin;
  int status_clock_gettime_end;
  double gurobi_total_run_time;
  #if COMPILEMSVS
    status_clock_gettime_begin = my_clock_gettime(CLOCK_REALTIME, &mybegin);
  #else
    status_clock_gettime_begin = clock_gettime(CLOCK_MONOTONIC_RAW, &mybegin);
  #endif
  gurobi_total_run_time = 0.0;
  dmiss = 0; // added in June 2016.
  for (i=1;i<=ntasks;i++) {
    tasks[i].valid = 0;
  }
  for (i=1;((i<=ntasks) && (!dmiss));i++) { // modified in June 2016.
    do_setup_data_structures( i);
    convg = 0; dmiss = 0; newt = compute_lb_of_worstcase_response_time(i);
    while ((!convg) && (!dmiss)) {
      t = newt;
      req_basic( i, t, &feas, &newt);
      gurobi_total_run_time = gurobi_total_run_time + gurobi_run_time;
      convg = (newt<=t); dmiss = (newt>tasks[i].D);
    }
    if ((convg) && (!dmiss))  {
      tasks[i].valid = 1;
      tasks[i].RUB = newt;
    }    
  }
  allvalid = 1;
  for (i=1;i<=ntasks;i++) {
    allvalid = allvalid && (tasks[i].valid); 
  }
  #if COMPILEMSVS
    status_clock_gettime_end = my_clock_gettime(CLOCK_REALTIME, &myend);
  #else
    status_clock_gettime_end = clock_gettime(CLOCK_MONOTONIC_RAW, &myend);
  #endif
  #if COMPILEMSVS
    timerequiredforschedulabilityanalysis_newmethod =  diff_s_timeval(&myend, &mybegin);
  #else
    timerequiredforschedulabilityanalysis_newmethod =  diff_s_timespec(&myend, &mybegin);
  #endif
  foutclockinfo = fopen( "clock_info_reqlpmethod.txt", "w");
  fprintf( foutclockinfo, "%lf %ld %ld %ld %ld %d %d %lf", timerequiredforschedulabilityanalysis_newmethod, mybegin.tv_sec, mybegin.tv_nsec, myend.tv_sec, myend.tv_nsec, status_clock_gettime_begin, status_clock_gettime_end, gurobi_total_run_time);
  fclose(foutclockinfo);

  if (allvalid) {
    printf("Schedulable\n");
    return 1;
  } else {
    printf("Don't know\n");
    return 0;
  }
}

double getbaselineexecutiontimeoftask( int j) {
  int k; double sum; double term; double worstpwforthissegment; int allnonzero;
  allnonzero = 1;

  for (k=1;k<=tasks[j].nsegments;k++) {
    allnonzero = allnonzero && (getworstpwforthissegment(j, k)>0);
  }
  if (!allnonzero) {
    printf("Error in getbaselineexecutiontimeoftask. There is a segment that can have zero progress. This is not necessarily a bad system. But it is a system for which this operation cannot be performed.\n");
    exit(-1);
  }
  sum = 0.0;
  for (k=1;k<=tasks[j].nsegments;k++) {
    worstpwforthissegment = getworstpwforthissegment(j, k);
    term = tasks[j].segments[k].C / worstpwforthissegment;
    sum = sum + term;
  }
  return sum;
}

void req_basic_baselinemethod( int i, double t, int* feas, double* value )
{
  int j; double sum; double term;
  sum = getbaselineexecutiontimeoftask( i);
  for (j=1;j<=ntasks;j++) {
    if (is_in_hepx( i, j)) {
      term = ceil(t/tasks[j].T) * getbaselineexecutiontimeoftask( j);
      sum = sum + term;
    }
  }
  *feas = 1;
  *value = sum;
}

int determineschedulabilityandcomputeresponsetimes_with_baselinemethod()
{
  int i; double t; double newt; int feas; int convg; int dmiss; int allvalid; FILE* foutclockinfo;
  int iprime; int kprime;
  #if COMPILEMSVS
    struct timeval mybegin;
    struct timeval myend;
  #else
    struct timespec mybegin;
    struct timespec myend;
  #endif
  int status_clock_gettime_begin;
  int status_clock_gettime_end;
  #if COMPILEMSVS
    status_clock_gettime_begin = my_clock_gettime(CLOCK_REALTIME, &mybegin);
  #else
    status_clock_gettime_begin = clock_gettime(CLOCK_MONOTONIC_RAW, &mybegin);
  #endif
  dmiss = 0; // added in June 2016.
  for (i=1;i<=ntasks;i++) {
    tasks[i].valid_baselinemethod = 0; 
  }
  for (i=1;((i<=ntasks) && (!dmiss));i++) { // modified in June 2016.
    do_setup_data_structures( i);
    convg = 0; dmiss = 0; newt = getbaselineexecutiontimeoftask( i); // compute_lb_of_worstcase_response_time(i);
    while ((!convg) && (!dmiss)) {
      t = newt;
      req_basic_baselinemethod( i, t, &feas, &newt);
      convg = (newt<=t); dmiss = (newt>tasks[i].D);
    }
    if ((convg) && (!dmiss)) {
      tasks[i].valid_baselinemethod = 1;
      tasks[i].RUB_baselinemethod = newt;
    }
  }
  allvalid = 1;
  for (i=1;i<=ntasks;i++) {
    allvalid = allvalid && (tasks[i].valid_baselinemethod); 
  }
  #if COMPILEMSVS
    status_clock_gettime_end = clock_gettime(CLOCK_REALTIME, &myend);
  #else
    status_clock_gettime_end = clock_gettime(CLOCK_MONOTONIC_RAW, &myend);
  #endif
  #if COMPILEMSVS
    timerequiredforschedulabilityanalysis_baselinemethod =  diff_s_timeval(&myend, &mybegin);
  #else
    timerequiredforschedulabilityanalysis_baselinemethod =  diff_s_timespec(&myend, &mybegin);
  #endif
  foutclockinfo = fopen( "clock_info_baselinemethod.txt", "w");
  fprintf( foutclockinfo, "%lf %ld %ld %ld %ld %d %d", timerequiredforschedulabilityanalysis_newmethod, mybegin.tv_sec, mybegin.tv_nsec, myend.tv_sec, myend.tv_nsec, status_clock_gettime_begin, status_clock_gettime_end);
  fclose(foutclockinfo);
  if (allvalid) {
    printf("Schedulable. baselinemethod\n");
    return 1;
  } else {
    printf("Don't know. baselinemethod\n");
    return 0;
  }
}

int determineschedulabilityandcomputeresponsetimes()
{
  int flag;
  system("sync"); // we do this to ensure that data is written back to disk. We do not want such writeback to happen when we run our schedulability analysis because this would interfer
                  // with timing measurements
  // sleep(1); // we do this in order to let the processor cool down
  if (useanalysismethod==1) {
    flag = determineschedulabilityandcomputeresponsetimes_with_reqlpmethod();
  }
  // sleep(1); // we do this in order to let the processor cool down
  determineschedulabilityandcomputeresponsetimes_with_baselinemethod();
  return flag;
}

void parsearguments( int argc, char *argv[], char *envp[])
{
  int i;
  i = 1;
  while (i<=argc-1) {
    if (strcmp( argv[i], "-i")==0) {
      strcpy( inputfilename, argv[i+1] );
      i = i + 2;
    } else {
      if (strcmp( argv[i], "-o")==0) {
        strcpy( outputfilename, argv[i+1] );
        i = i + 2;
      } else {
        if (strcmp( argv[i], "-g")==0) { // do in batchmode: generate tasksets
          generate_experiments = 1;
          i = i + 1;
        } else {
          if (strcmp( argv[i], "-r")==0) { // do in batchmode: check schedulability of the generated tasksets
            run_experiments = 1;
            i = i + 1;
          } else {
            if (strcmp( argv[i], "-s")==0) { // do in batchmode: gather statistics
              generate_statistics = 1;
              i = i + 1;
            } else {
              if (strcmp( argv[i], "-m")==0) { // do many experiments in batchmode
                metathing = 1;
                i = i + 1;
              } else {
                if (strcmp( argv[i], "-p")==0) { // produce tasksets from parts
                  producetasksetsfromparts = 1;
                  strcpy( producetasksetsfrompartsfilename, argv[i+1] );
                  i = i + 2;
                } else {
                  i++;
                }
              }
            }
          }
        }
      }
    }
  }
}

int my_int_random(int lb, int ub)
{
  int t; int t2; int t3;
  t = myrandom();
  t2 = t % (ub-lb+1);
  t3 = lb + t2;
  return t3;
}

double my_double_random(double lo, double hi)
{
  double t; double t2; double t3;
  t = mydrand48();
  t2 = t*(hi-lo);
  t3 = lo + t2;
  return t3;
}

int getntasksbasedonvector(int* ntasks_on_proc)
{
  int p; int actualntasks;
  actualntasks = 0;
  for (p=1;p<=nprocessors;p++) {
    actualntasks = actualntasks + ntasks_on_proc[p];
  }
  return actualntasks;
}

// void generate_tasks_randomly(double targetutil)
void generate_tasks_randomly() {
  int i; int k;
  double targetutilfortask; double targetutilforsegment;
  double loboundC; double hiboundC;
  targetutilfortask = (1.0*nprocessors)/ntasks;
  for (i=1;i<=ntasks;i++) {
    tasks[i].id = i;
    tasks[i].priority = ntasks - i;
    tasks[i].proc     = -1;
    tasks[i].T = 1.0;
    tasks[i].D = 1.0;
    tasks[i].nsegments = nsg;
    targetutilforsegment = targetutilfortask / tasks[i].nsegments; 
    loboundC = 0.001;
    hiboundC = 2*targetutilforsegment - loboundC;
    for (k=1;k<=tasks[i].nsegments;k++) {
      // tasks[i].segments[k].segid = 1;
      tasks[i].segments[k].segid = k; // On July 17, 2020, I found that the line above (assigning segid = 1) is incorrect; it should be segid=k.
                                      // So, I corrected it.
                                      // Fortunately, this error does not impact any computed result in terms of determining scheedulability.
                                      // Its impact is that when the generated tasksets are written to file, there all segments of a single
                                      // tasks will be written as if they have the same index. But once again, segid is not used in schedulability
                                      // analysis to the schedulability analysis is correct anyway.
      tasks[i].segments[k].C  = my_double_random(loboundC,hiboundC);
      tasks[i].segments[k].pd = 1.0;
      tasks[i].segments[k].ncorunnersetsspecified = 0;
    }
  }
}

double mypow( double t1, double t2)
{
  double temp; double temp2;
  temp = t2*log(t1);
  temp2 = exp( temp);
  return temp2;
}

void changeToftasks()
{
  int i; int s; double t0; double t1;
  for (i=1;i<=ntasks;i++) {
    t0 = my_double_random(0.0,4.0);
    t1 = mypow( 10.0, 2+t0);
    tasks[i].D = t1 * tasks[i].D;
    tasks[i].T = t1 * tasks[i].T;
    for (s=1;s<=tasks[i].nsegments;s++) {
      tasks[i].segments[s].C = tasks[i].segments[s].C * t1;
    }
  }  
}

void setTDsothatDTmaybedifferent()
{
  int i; double t1;
  for (i=1;i<=ntasks;i++) {
    t1 = 1.0;
    tasks[i].D = t1 * tasks[i].T;
  }
}

double getsumC(int i) {
  double sumC; int s;
  sumC = 0.0;
  for (s=1;s<=tasks[i].nsegments;s++) {
    sumC = sumC + tasks[i].segments[s].C;
  }
  return sumC;
}

void assignTDCoftasks()
{
  generate_tasks_randomly();
  changeToftasks();
  setTDsothatDTmaybedifferent();
}

int gettaskwithhighestutilamongtasksthatarenotassigned()
{
  int i; int taskwithhighestutil;
  taskwithhighestutil = -1;
  for (i=1;i<=ntasks;i++) {
    if (tasks[i].proc==-1) {
      if (taskwithhighestutil!=-1) {
        if (getutiloftask(taskwithhighestutil)<getutiloftask(i)) {
          taskwithhighestutil = i;
        }
      } else {
       taskwithhighestutil = i;
      }
    }
  }
  return taskwithhighestutil;
}

int getprocessorwithlowestutilization()
{
  int p; int processorwithlowestutil;
  processorwithlowestutil = 1;
  for (p=2;p<=nprocessors;p++) {
    if (getutilofprocessor(p) < getutilofprocessor(processorwithlowestutil)) {
      processorwithlowestutil = p;
    }
  }
  return processorwithlowestutil;
}

void assigntaskstoprocessors()
{
  int i; int p;
  for (i=1;i<=ntasks;i++) {
    tasks[i].proc = -1;
  }
  i = gettaskwithhighestutilamongtasksthatarenotassigned();
  p = getprocessorwithlowestutilization();
  while (i!=-1) {
    tasks[i].proc = p;
    i = gettaskwithhighestutilamongtasksthatarenotassigned();
    p = getprocessorwithlowestutilization();
  }
}

int check_sched_without_co_runners() {
  int i; double t; double newt; int j;
  for (i=1;i<=ntasks;i++) {
    t = 0; newt = getsumC(i);
    while ((newt>t) && (newt<=tasks[i].D)) {
      t = newt;
      newt = 0.0; for (j=1;j<=ntasks;j++) { if (is_in_hep( i, j)) { newt = newt + ceil(t/tasks[j].T) * getsumC(j); } }
    }
    if (newt>tasks[i].D) {
      return 0;
    }
  }
  return 1;
}

void scale_taskset_by_factor( double factor) {
  int i; int s;
  for (i=1;i<=ntasks;i++) {
    for (s=1;s<=tasks[i].nsegments;s++) {
      tasks[i].segments[s].C = tasks[i].segments[s].C * factor;
    }
  }
}

void scale_taskset_so_that_it_is_critically_schedulable_without_co_runner_interference() {
  int flag; double factor; double tolerance;
  factor = 2.0;
  flag = check_sched_without_co_runners();
  while (flag) {
    scale_taskset_by_factor( factor); 
    flag = check_sched_without_co_runners();    
  }
  while (!flag) {
    scale_taskset_by_factor( 1.0/factor); 
    flag = check_sched_without_co_runners();    
  }
  // now we have a taskset that is schedulable but multiplying execution times by factor makes it unschedulable.
  tolerance = 1.01;
  while (factor>tolerance) {
    scale_taskset_by_factor( sqrt(factor)); 
    flag = check_sched_without_co_runners();    
    if (!flag) {
      scale_taskset_by_factor( 1.0/sqrt(factor));
    }
    factor = sqrt(factor);
  }
}

int is_segmentset_equal_to(int iprime, int kprime, int segmentsetindex) {
  return  ( (segmentsets[segmentsetindex].taskindices[tasks[iprime].proc-1] == iprime) &&
            (segmentsets[segmentsetindex].segmentindices[tasks[iprime].proc-1] == kprime) );
}

int is_segmentset_empty(int pprime, int segmentsetindex) {
  return  ( (segmentsets[segmentsetindex].taskindices[pprime-1] == -1) &&
            (segmentsets[segmentsetindex].segmentindices[pprime-1] == -1) );
}

void assigninitialcorunnerdependenciesforgivensegmentforagivencurrentset(int iprime, int kprime, int corindex, double r, int segmentsetindex) {
  double t1; int counter;
  int iprimeprime; int kprimeprime;
  t1 = my_double_random( r, 1.00);
  tasks[iprime].segments[kprime].corunnersetsspecified[ corindex ].progresscorunnerset = t1;
  tasks[iprime].segments[kprime].corunnersetsspecified[ corindex ].nsegmentsincorunnerset = 0; // this lines is actually not needed
  counter = 0;
  for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
    for (kprimeprime=1;kprimeprime<=tasks[iprimeprime].nsegments;kprimeprime++) {
      if ( (tasks[iprimeprime].proc != tasks[iprime].proc) && (is_segmentset_equal_to(iprimeprime,kprimeprime,segmentsetindex))) {
        counter = counter + 1;
        tasks[iprime].segments[kprime].corunnersetsspecified[ corindex ].segmentsincorunnerset[counter].taskindex = iprimeprime;
        tasks[iprime].segments[kprime].corunnersetsspecified[ corindex ].segmentsincorunnerset[counter].segmentindex  = kprimeprime;
      }
    }
  }
  tasks[iprime].segments[kprime].corunnersetsspecified[ corindex ].nsegmentsincorunnerset = counter;
}

int segmentset_includes_this_segment_and_at_least_one_more(int iprime, int kprime,int segmentsetindex) {
  int pprime; int found_self; int found_empty; int found_other;
  found_self = 0; found_other = 0;
  for (pprime=1;pprime<=nprocessors;pprime++) {
    if (pprime==tasks[iprime].proc) {
      if (is_segmentset_equal_to(iprime,kprime,segmentsetindex)) {
        found_self = 1;
      }
    } else {
      if (!is_segmentset_empty(pprime, segmentsetindex)) {
        found_other = 1;
      }
    }
  }
  return (found_self && found_other);
}

void assigninitialcorunnerdependenciesforgivensegment(int iprime, int kprime, double r) {
  int segmentsetindex;
  tasks[iprime].segments[kprime].ncorunnersetsspecified = 0;
  for (segmentsetindex=0;segmentsetindex<nsegmentsets;segmentsetindex++) {
    if (segmentset_includes_this_segment_and_at_least_one_more(iprime, kprime,segmentsetindex)) {
      tasks[iprime].segments[kprime].ncorunnersetsspecified = tasks[iprime].segments[kprime].ncorunnersetsspecified + 1;
      if (tasks[iprime].segments[kprime].ncorunnersetsspecified + 1 > MAXNCORUNNERSETSSPECIFIED) {
        printf("Error in assigninitialcorunnerdependenciesforgivensegment. Not enough memory.\n"); fflush(stdout);
        exit(-1);
      }
      assigninitialcorunnerdependenciesforgivensegmentforagivencurrentset( iprime, kprime, tasks[iprime].segments[kprime].ncorunnersetsspecified, r, segmentsetindex);
    }
  }
}

void assigninitialcorunnerdependencies(double r)
{
  int iprime; int kprime;
  for (iprime=1;iprime<=ntasks;iprime++) {
    do_setup_data_structures(iprime);
    for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
      assigninitialcorunnerdependenciesforgivensegment( iprime, kprime, r);
    }
  }
}

// dominates menas that there is something that cri1 has but cri2 does not
int dominatessegmentsubset(int i, int s, int cri1, int cri2) {
  int t1; int t2; int found;
  for (t1=1;t1<=tasks[i].segments[s].corunnersetsspecified[ cri1 ].nsegmentsincorunnerset;t1++) {
    found = 0;
    for (t2=1;t2<=tasks[i].segments[s].corunnersetsspecified[ cri2 ].nsegmentsincorunnerset;t2++) {
      if ( (tasks[i].segments[s].corunnersetsspecified[ cri1 ].segmentsincorunnerset[t1].taskindex    == tasks[i].segments[s].corunnersetsspecified[ cri2 ].segmentsincorunnerset[t2].taskindex) && 
           (tasks[i].segments[s].corunnersetsspecified[ cri1 ].segmentsincorunnerset[t1].segmentindex == tasks[i].segments[s].corunnersetsspecified[ cri2 ].segmentsincorunnerset[t2].segmentindex) ) {
        found = 1;  
      }
    }
    if (!found) {
      return 0;
    }
  }
  return 1;
}

void detectinversion(int i, int s, int* pcri1, int* pcri2)
{
  int found; int cri1; int cri2;
  *pcri1 = -1;
  *pcri2 = -1;
  found = 0;
  for (cri1=1;cri1<=tasks[i].segments[s].ncorunnersetsspecified;cri1++) {
    for (cri2=cri1+1;cri2<=tasks[i].segments[s].ncorunnersetsspecified;cri2++) {
      if (!found) {
        if (dominatessegmentsubset(i,s, cri1, cri2)) {
          if (tasks[i].segments[s].corunnersetsspecified[ cri1 ].progresscorunnerset < tasks[i].segments[s].corunnersetsspecified[ cri2 ].progresscorunnerset ) {
            *pcri1 = cri1;
            *pcri2 = cri2;
            found = 1;
          }
        }
      }
    }
  }
}

void recomputepdforaspecificsegment(int i, int s, double r)
{
  tasks[i].segments[s].pd = r;
}

void recomputepd(double r)
{
  int i; int s;
  for (i=1;i<=ntasks;i++) {
    for (s=1;s<=tasks[i].nsegments;s++) {
      recomputepdforaspecificsegment(i,s,r);
    }
  }
}

void swap_corunnersetsspecified(int i,int s,int index_i,int index_j) {
  int temp; int l;
  struct segmentincorunnerset q;

  l = maxint2( tasks[i].segments[s].corunnersetsspecified[index_i].nsegmentsincorunnerset, tasks[i].segments[s].corunnersetsspecified[index_j].nsegmentsincorunnerset);

  temp = tasks[i].segments[s].corunnersetsspecified[index_i].nsegmentsincorunnerset;
  tasks[i].segments[s].corunnersetsspecified[index_i].nsegmentsincorunnerset = tasks[i].segments[s].corunnersetsspecified[index_j].nsegmentsincorunnerset;
  tasks[i].segments[s].corunnersetsspecified[index_j].nsegmentsincorunnerset = temp;

  for (temp=1;temp<=l;temp++) {
    q = tasks[i].segments[s].corunnersetsspecified[index_i].segmentsincorunnerset[temp];
    tasks[i].segments[s].corunnersetsspecified[index_i].segmentsincorunnerset[temp] = tasks[i].segments[s].corunnersetsspecified[index_j].segmentsincorunnerset[temp];
    tasks[i].segments[s].corunnersetsspecified[index_j].segmentsincorunnerset[temp] = q;
  }
}

void rearrangecorunnerdependencies_size(int i,int s,int lo,int hi) {
  int index_i; int index_j; int go_on; int p;
  int pivot; struct corunnersetspecifiedstruct* cortemp;
  if (lo<hi) {
    pivot = tasks[i].segments[s].corunnersetsspecified[lo].nsegmentsincorunnerset;
    index_i = lo - 1;
    index_j = hi + 1;
    go_on = 1;
    while (go_on) {
      do {
        index_j = index_j - 1;
      } while ((tasks[i].segments[s].corunnersetsspecified[index_j].nsegmentsincorunnerset) > pivot);
      do {
        index_i = index_i + 1;
      } while ((tasks[i].segments[s].corunnersetsspecified[index_i].nsegmentsincorunnerset) < pivot);
      if (index_i < index_j) {
        swap_corunnersetsspecified(i,s,index_i,index_j);
      } else {
        go_on = 0;
        p = index_j;
      }
    }
    rearrangecorunnerdependencies_size(i,s,lo,p);
    rearrangecorunnerdependencies_size(i,s,p+1,hi);
  }
}

void rearrangecorunnerdependencies_progresscorunnerset(int i,int s,int lo,int hi) {
  int index_i; int index_j; int go_on; int p;
  double pivot; double progresstemp;
  if (lo<hi) {
    pivot = tasks[i].segments[s].corunnersetsspecified[lo].progresscorunnerset;
    index_i = lo - 1;
    index_j = hi + 1;
    go_on = 1;
    while (go_on) {
      do {
        index_j = index_j - 1;
      } while ((tasks[i].segments[s].corunnersetsspecified[index_j].progresscorunnerset) < pivot);
      do {
        index_i = index_i + 1;
      } while ((tasks[i].segments[s].corunnersetsspecified[index_i].progresscorunnerset) > pivot);
      if (index_i < index_j) {
        progresstemp =  tasks[i].segments[s].corunnersetsspecified[index_i].progresscorunnerset;
        tasks[i].segments[s].corunnersetsspecified[index_i].progresscorunnerset = tasks[i].segments[s].corunnersetsspecified[index_j].progresscorunnerset;
        tasks[i].segments[s].corunnersetsspecified[index_j].progresscorunnerset = progresstemp;
      } else {
        go_on = 0;
        p = index_j;
      }
    }
    rearrangecorunnerdependencies_progresscorunnerset(i,s,lo,p);
    rearrangecorunnerdependencies_progresscorunnerset(i,s,p+1,hi);
  }
}

// we do this so as to avoid conflicts; this makes the code run faster -- see below.
void rearrangecorunnerdependencies() {
  int i; int s;
  for (i=1;i<=ntasks;i++) {
    for (s=1;s<=tasks[i].nsegments;s++) {
      rearrangecorunnerdependencies_size(                i,s,1,tasks[i].segments[s].ncorunnersetsspecified);
    }
  }
  for (i=1;i<=ntasks;i++) {
    for (s=1;s<=tasks[i].nsegments;s++) {
      rearrangecorunnerdependencies_progresscorunnerset( i,s,1,tasks[i].segments[s].ncorunnersetsspecified);
    }
  }
}

void sorttasksinDMorderandassignpriorities()
{
  int i; int j; int ntasks_with_shorter_deadline;
  for (i=1;i<=ntasks;i++) {
    ntasks_with_shorter_deadline = 0;
    for (j=1;j<=ntasks;j++) {
      if (j!=i) {
        if (tasks[j].D < tasks[i].D) {
          ntasks_with_shorter_deadline  = ntasks_with_shorter_deadline + 1;
        }
      }
    }
    tasks[i].priority = ntasks - ntasks_with_shorter_deadline;
  }
}

void getindices_from_metaindex(int loc_metaindex, int* p_index1, int* p_index2) {
  *p_index1 = (((loc_metaindex-1) / 20)+1);  
  *p_index2 = (((loc_metaindex-1) % 20)+1);  
}

void get_mul_and_r_from_metaindex(int loc_metaindex, double* p_mult, double* p_r) {
  int index1; int index2;
  getindices_from_metaindex( loc_metaindex, &index1, &index2);
  *p_mult = index1 * 0.05;
  *p_r    = index2 * 0.05;
  if ((loc_metaindex>=401) || (loc_metaindex<=0)) { printf("Error in do_generate_experiments\n"); exit(0); }
}

int should_this_metaindex_be_included(int metaindex) {
  int index1; int index2;
  getindices_from_metaindex( metaindex, &index1, &index2);
  return (index1>index2); 
}

void write_mult_and_PROGMIN_to_file_based_on_metaindex(char* fn, int loc_metaindex) {
  double loc_mult; double loc_PROGMIN; FILE* fout;
  get_mul_and_r_from_metaindex(loc_metaindex, &loc_mult, &loc_PROGMIN);
  fout = fopen(fn, "w");
  fprintf(fout,"mult = %lf PROGMIN=%lf\n", loc_mult, loc_PROGMIN);
  fclose( fout);  
}

void do_generate_experiments(int metaindex)
{
  char tempstr[20000]; int iterator; double mult; char tempstring2[20000]; int error1; int error2; double r;
  for (iterator=1;iterator<=MAX_ITERATOR_IN_BATCH;iterator++) {
    mymakedirectory("experiments");
    mychdir("experiments");
    mymakedirectory("experiment1");
    mychdir("experiment1");
    sprintf(tempstr,"taskset%d",iterator);
    error1 = mymakedirectory(tempstr);
    sprintf(tempstr,"taskset%d",iterator);
    error2 = mychdir(tempstr);
    useanalysismethod = 1;
    if (metathing==0) { nprocessors = 4; }
    get_mul_and_r_from_metaindex( metaindex, &mult, &r);
    if (metathing==0) { ntasks = 10; }
    assignTDCoftasks();
    sorttasksinDMorderandassignpriorities();
    assigntaskstoprocessors();
    scale_taskset_so_that_it_is_critically_schedulable_without_co_runner_interference();
    scale_taskset_by_factor( mult);
    assigninitialcorunnerdependencies( r);
    rearrangecorunnerdependencies();
    recomputepd(r);
    writetasksettofile("taskset.txt");
    mychdir("..");
    mychdir("..");
    mychdir("..");
  }
}

void do_run_experiments()
{
  int iterator;
  char tempstr[20000];
  for (iterator=1;iterator<=MAX_ITERATOR_IN_BATCH;iterator++) {
    mychdir("experiments");
    mychdir("experiment1");
    sprintf(tempstr,"taskset%d",iterator);
    mychdir(tempstr);
      
    readtasksetfromfile("taskset.txt");

    determineschedulabilityandcomputeresponsetimes();

    writeresponsetimestofile(outputfilename);
    mychdir("..");
    mychdir("..");
    mychdir("..");
  }
}

void readsuccessandtime(char* infn, int* psuccess_newmethod, double* ptimetaken_newmethod, int* psuccess_baselinemethod, double* ptimetaken_baselinemethod)
{
  FILE* myfile;
  myfile = fopen( infn, "r");
  fscanf( myfile, "%d %lf %d %lf", psuccess_newmethod, ptimetaken_newmethod, psuccess_baselinemethod, ptimetaken_baselinemethod);
  fclose( myfile);
}

void do_generate_statistics()
{
  char infn[20000];
  char outfn[20000];
  int success_newmethod; double timetaken_newmethod;
  int success_baselinemethod; double timetaken_baselinemethod;
  int iterator;
  FILE* myfile;
  #if COMPILEMSVS
    sprintf(outfn,"experiments\\experiment1\\statistics.txt");
  #else
    sprintf(outfn,"experiments/experiment1/statistics.txt");
  #endif
  myfile = fopen( outfn, "w");
  for (iterator=1;iterator<=MAX_ITERATOR_IN_BATCH;iterator++) {
    #if COMPILEMSVS
      printf(infn,"experiments\\experiment1\\taskset%d\\taskset_results_from_analysis.txt",iterator);
    #else
      sprintf(infn,"experiments/experiment1/taskset%d/taskset_results_from_analysis.txt",iterator);
    #endif
    readsuccessandtime(infn, &success_newmethod, &timetaken_newmethod, &success_baselinemethod, &timetaken_baselinemethod);
    fprintf( myfile, "%d %lf %d %lf\n", success_newmethod, timetaken_newmethod, success_baselinemethod, timetaken_baselinemethod);
  }
  fclose( myfile);
}


void initialize_random_generator()
{
  #if COMPILEMSVS
    srand(137);
  #else
    srand(137);
  #endif
}

// this function is not used. But we keep it in case we need it in the future.
void OLD_addtooverallstatistics( FILE* myfile, char* fninput)
{
  FILE* fin; char readstring[20000]; int nlinesread;
  double successnewmethod;     double mintnewmethod;     double maxtnewmethod;
  double successbaselinemethod; double mintbaselinemethod; double maxtbaselinemethod;
  int t1; double t2; int t3; double t4;

  nlinesread = 0;
  successnewmethod = 0;     mintnewmethod = -1;     maxtnewmethod = -1;
  successbaselinemethod = 0; mintbaselinemethod = -1; maxtbaselinemethod = -1;
  fin = fopen( fninput, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %lf %d %lf", &t1, &t2, &t3, &t4);
    nlinesread = nlinesread+ 1;
    successnewmethod     = successnewmethod     + t1;
    if (mintnewmethod==-1) {
      mintnewmethod = t2;
    } else {
      if (t2<mintnewmethod) {
        mintnewmethod = t2;
      }
    }
    if (maxtnewmethod==-1) {
      maxtnewmethod = t2;
    } else {
      if (t2>maxtnewmethod) {
        maxtnewmethod = t2;
      }
    }
    successbaselinemethod     = successbaselinemethod     + t3;
    if (mintbaselinemethod==-1) {
      mintbaselinemethod = t4;
    } else {
      if (t4<mintbaselinemethod) {
        mintbaselinemethod = t4;
      }
    }
    if (maxtbaselinemethod==-1) {
      maxtbaselinemethod = t4;
    } else {
      if (t4>maxtbaselinemethod) {
        maxtbaselinemethod = t4;
      }
    }
  }
  fclose( fin);
  successnewmethod     = successnewmethod     / nlinesread;
  successbaselinemethod = successbaselinemethod / nlinesread;
  fprintf( myfile, "%d %d %d %lf %lf %lf %lf %lf %lf\n",
    nprocessors, ntasks, nsg,
    successnewmethod,     mintnewmethod,     maxtnewmethod,
    successbaselinemethod, mintbaselinemethod, maxtbaselinemethod
  );
}

void addtooverallstatistics( FILE* myfile, char* fninput)
{
  FILE* fin; char readstring[20000]; int nlinesread;
  double successnewmethod;     double mintnewmethod;     double maxtnewmethod;
  double successbaselinemethod; double mintbaselinemethod; double maxtbaselinemethod;
  int t1; double t2; int t3; double t4;

  nlinesread = 0;
  successnewmethod = 0;     mintnewmethod = -1;     maxtnewmethod = -1;
  successbaselinemethod = 0; mintbaselinemethod = -1; maxtbaselinemethod = -1;
  fin = fopen( fninput, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %lf %d %lf", &t1, &t2, &t3, &t4);
    nlinesread = nlinesread+ 1;
    successnewmethod     = successnewmethod     + t1;
    if (mintnewmethod==-1) {
      mintnewmethod = t2;
    } else {
      if (t2<mintnewmethod) {
        mintnewmethod = t2;
      }
    }
    if (maxtnewmethod==-1) {
      maxtnewmethod = t2;
    } else {
      if (t2>maxtnewmethod) {
        maxtnewmethod = t2;
      }
    }
    successbaselinemethod     = successbaselinemethod     + t3;
    if (mintbaselinemethod==-1) {
      mintbaselinemethod = t4;
    } else {
      if (t4<mintbaselinemethod) {
        mintbaselinemethod = t4;
      }
    }
    if (maxtbaselinemethod==-1) {
      maxtbaselinemethod = t4;
    } else {
      if (t4>maxtbaselinemethod) {
        maxtbaselinemethod = t4;
      }
    }
  }
  fclose( fin);
  successnewmethod     = successnewmethod     / nlinesread;
  successbaselinemethod = successbaselinemethod / nlinesread;
  fprintf( myfile, "%d %d %d %lf %lf %lf %lf\n",
    nprocessors, ntasks, nsg,
    successnewmethod,     maxtnewmethod,
    successbaselinemethod, maxtbaselinemethod
  );
}

void createdirectorynameforthismetacase(char* metadirectoryforthiscase, int nprocessors, int ntasks, int nsg)
{
  sprintf( metadirectoryforthiscase, "m%dn%ds%d", nprocessors, ntasks, nsg);
}

double roundup_to_ms(double t)
{
  return ((ceil(1000.0*t))/1000.0);
}

// This function is currently not used. But we my want to use it in the future.
void old_generate_latex_from_overallstatistics(char* sourcefn, char* destfn)
{
  FILE* fin; FILE* fout;
  char readstring[20000];
  int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  fin  = fopen( sourcefn, "r"); fout = fopen( destfn, "w");
  fprintf(fout, "\\begin{tabular}{|r|r|r|r|r|r|r|r|r|} \\hline \\hline \n");
  fprintf(fout, "$|\\mathrm{procs}(\\Pi)|$ & $|\\tau|$ & nsg                      & \\multicolumn{3}{c|}{New method}       & \\multicolumn{3}{c|}{Baseline method} \\\\                \n");
  fprintf(fout, "         &            &                          & succ      &     mint   &    maxt      & succ      & mint     & maxt         \\\\ \\hline \\hline  \n"); 
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &mint_newmethod, &maxt_newmethod, &succ_baselinemethod, &mint_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %d      & %d         & %d                       & %.2lf       &     %6.3lf    &    %6.3lf       & %.2lf        & %6.3lf      & %6.3lf          \\\\ \\hline  \n",temp1, temp2, temp3, succ_newmethod, roundup_to_ms(mint_newmethod), roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(mint_baselinemethod), roundup_to_ms(maxt_baselinemethod) ); 
  }
  fprintf(fout,"\\end{tabular} \n");
  fclose( fout); fclose( fin);
}

void generate_latex_from_overallstatistics(char* sourcefn, char* destfn)
{
  FILE* fin; FILE* fout;
  char readstring[20000];
  int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  fin  = fopen( sourcefn, "r"); fout = fopen( destfn, "w");
  fprintf(fout, "\\begin{tabular}{|r|r|r|r|r|r|r|} \\hline \\hline \n");
  fprintf(fout, "$|\\mathrm{procs}(\\Pi)|$ & $|\\tau|$ & nsg                      & \\multicolumn{2}{c|}{New method}       & \\multicolumn{2}{c|}{Baseline method} \\\\                \n");
  fprintf(fout, "         &            &                          & succ      &    maxt      & succ      & maxt         \\\\ \\hline \\hline  \n"); 
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n",temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fprintf(fout,"\\end{tabular} \n");
  fclose( fout); fclose( fin);
}

// This function is currently not used. But we my want to use it in the future.
void old_do_metathing(int metaindex)
{
  char metadirectoryforthiscase[20000]; FILE* myfile;
  myfile = fopen( "overallstatistics.txt", "w");
  for (nprocessors=2;nprocessors<=8;nprocessors++) {
    ntasks = nprocessors+1;
    for (nsg=1;nsg<=2;nsg++) {
      createdirectorynameforthismetacase(metadirectoryforthiscase, nprocessors, ntasks, nsg);
      mymakedirectory(metadirectoryforthiscase);
      mychdir(metadirectoryforthiscase);
      do_generate_experiments(metaindex);
      do_run_experiments();
      do_generate_statistics();
      #if COMPILEMSVS
        addtooverallstatistics( myfile, "experiments\\experiment1\\statistics.txt");
      #else
        addtooverallstatistics( myfile, "experiments/experiment1/statistics.txt");
      #endif
      mychdir("..");
    }
    ntasks = 10;
    for (nsg=1;nsg<=2;nsg++) {
      createdirectorynameforthismetacase(metadirectoryforthiscase, nprocessors, ntasks, nsg);
      mymakedirectory(metadirectoryforthiscase);
      mychdir(metadirectoryforthiscase);
      do_generate_experiments(metaindex);
      do_run_experiments();
      do_generate_statistics();
      #if COMPILEMSVS
        addtooverallstatistics( myfile, "experiments\\experiment1\\statistics.txt");
      #else
        addtooverallstatistics( myfile, "experiments/experiment1/statistics.txt");
      #endif
      mychdir("..");
    }
  }
  fclose( myfile);
  generate_latex_from_overallstatistics("overallstatistics.txt","overallstatistics.tex");
}

void do_metathing_generate_experiments(int metaindex) {
  char metadirectoryforthiscase[20000];
  for (nprocessors=2;nprocessors<=8;nprocessors++) {
    for (ntasks=2;ntasks<=16;ntasks+=2) {
      for (nsg=1;nsg<=2;nsg++) {
        createdirectorynameforthismetacase(metadirectoryforthiscase, nprocessors, ntasks, nsg);
        mymakedirectory(metadirectoryforthiscase);
        mychdir(metadirectoryforthiscase);
        do_generate_experiments(metaindex);
        mychdir("..");
      }
    }
  }
}

void do_metathing_run_experiments(int metaindex) {
  char metadirectoryforthiscase[20000]; FILE* myfile;
  myfile = fopen( "overallstatistics.txt", "w");
  for (nprocessors=2;nprocessors<=8;nprocessors++) {
    for (ntasks=2;ntasks<=16;ntasks+=2) {
      for (nsg=1;nsg<=2;nsg++) {
        createdirectorynameforthismetacase(metadirectoryforthiscase, nprocessors, ntasks, nsg);
        mychdir(metadirectoryforthiscase);
        do_run_experiments();
        do_generate_statistics();
        #if COMPILEMSVS
          addtooverallstatistics( myfile, "experiments\\experiment1\\statistics.txt");
        #else
          addtooverallstatistics( myfile, "experiments/experiment1/statistics.txt");
        #endif
        mychdir("..");
      }
    }
  }
  fclose( myfile);
  generate_latex_from_overallstatistics("overallstatistics.txt","overallstatistics.tex");
}

void do_metathing(int metaindex)
{
  do_metathing_generate_experiments(metaindex);
  do_metathing_run_experiments(metaindex);
}

// This function is currently not used. But we my want to use it in the future.
void old_createone_of_the_three_tables(char* sourcefn1, char* sourcefn2, char* destfn)
{
  FILE* fin; FILE* fout;
  char readstring[20000];
  int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  fout = fopen( destfn, "w");
  fprintf(fout, "\\begin{tabular}{|r|r|r|r|r|r|r|r|r|r|} \\hline \\hline \n");
  fprintf(fout, "$\\mathrm{PROGMIN}$ & $|\\mathrm{procs}(\\Pi)|$ & $|\\tau|$ & nsg                      & \\multicolumn{3}{c|}{New method}       & \\multicolumn{3}{c|}{Baseline method} \\\\                \n");
  fprintf(fout, "       &                           &            &                          & succ      &     mint   &    maxt      & succ      & mint     & maxt         \\\\ \\hline \\hline  \n"); 
  fin  = fopen( sourcefn1, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &mint_newmethod, &maxt_newmethod, &succ_baselinemethod, &mint_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf    & %d      & %d         & %d                       & %.2lf       &     %6.3lf    &    %6.3lf       & %.2lf        & %6.3lf      & %6.3lf          \\\\ \\hline  \n",1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(mint_newmethod), roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(mint_baselinemethod), roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);
  fin  = fopen( sourcefn1, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &mint_newmethod, &maxt_newmethod, &succ_baselinemethod, &mint_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf    & %d      & %d         & %d                       & %.2lf       &     %6.3lf    &    %6.3lf       & %.2lf        & %6.3lf      & %6.3lf          \\\\ \\hline  \n",1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(mint_newmethod), roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(mint_baselinemethod), roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);
  fprintf(fout,"\\end{tabular} \n");
  fclose( fout);
}

void createone_of_the_three_tables(char* sourcefn1, char* sourcefn2, char* destfn)
{
  FILE* fin; FILE* fout;
  char readstring[20000];
  int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  fout = fopen( destfn, "w");
  fprintf(fout, "\\begin{tabular}{|r|r|r|r|r|r|r|r|} \\hline \\hline \n");
  fprintf(fout, "$\\mathrm{PROGMIN}$ & $|\\mathrm{procs}(\\Pi)|$ & $|\\tau|$ & nsg                      & \\multicolumn{2}{c|}{New method}       & \\multicolumn{2}{c|}{Baseline method} \\\\                \n");
  fprintf(fout, "       &                           &            &                          & succ      &    maxt      & succ      & maxt         \\\\ \\hline \\hline  \n"); 
  fin  = fopen( sourcefn1, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n",1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);
  fin  = fopen( sourcefn2, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf    & %d      & %d         & %d                       & %.2lf       &     %6.3lf    & %.2lf        & %6.3lf          \\\\ \\hline  \n",1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);
  fprintf(fout,"\\end{tabular} \n");
  fclose( fout);
}

void createthreetables()
{
  #if COMPILEMSVS
    createone_of_the_three_tables("meta1\\overallstatistics.txt","meta2\\overallstatistics.txt", "table1.tex");
  #else
    createone_of_the_three_tables("meta1/overallstatistics.txt","meta2/overallstatistics.txt", "table1.tex");
  #endif

  #if COMPILEMSVS
    createone_of_the_three_tables("meta3\\overallstatistics.txt","meta4\\overallstatistics.txt", "table2.tex");
  #else
    createone_of_the_three_tables("meta3/overallstatistics.txt","meta4/overallstatistics.txt", "table2.tex");
  #endif

  #if COMPILEMSVS
    createone_of_the_three_tables("meta5\\overallstatistics.txt","meta6\\overallstatistics.txt", "table3.tex");
  #else
    createone_of_the_three_tables("meta5/overallstatistics.txt","meta6/overallstatistics.txt", "table3.tex");
  #endif
}

void createfourtables()
{
  #if COMPILEMSVS
    createone_of_the_three_tables("meta1\\overallstatistics.txt","meta2\\overallstatistics.txt", "table1.tex");
  #else
    createone_of_the_three_tables("meta1/overallstatistics.txt","meta2/overallstatistics.txt", "table1.tex");
  #endif

  #if COMPILEMSVS
    createone_of_the_three_tables("meta3\\overallstatistics.txt","meta4\\overallstatistics.txt", "table2.tex");
  #else
    createone_of_the_three_tables("meta3/overallstatistics.txt","meta4/overallstatistics.txt", "table2.tex");
  #endif

  #if COMPILEMSVS
    createone_of_the_three_tables("meta5\\overallstatistics.txt","meta6\\overallstatistics.txt", "table3.tex");
  #else
    createone_of_the_three_tables("meta5/overallstatistics.txt","meta6/overallstatistics.txt", "table3.tex");
  #endif

  #if COMPILEMSVS
    createone_of_the_three_tables("meta7\\overallstatistics.txt","meta8\\overallstatistics.txt", "table4.tex");
  #else
    createone_of_the_three_tables("meta7/overallstatistics.txt","meta8/overallstatistics.txt", "table4.tex");
  #endif
}

void createsingletable() {
  FILE* fin; FILE* fout;
  char readstring[20000];
  int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  fout = fopen( "single_table.tex", "w");
  fprintf(fout, "\\begin{tabular}{|r|r|r|r|r|r|r|r|r|} \\hline \\hline \n");
  fprintf(fout, "$\\mathrm{mult}$ & $\\mathrm{PROGMIN}$ & $|\\mathrm{procs}(\\Pi)|$ & $|\\tau|$ & nsg                      & \\multicolumn{2}{c|}{New method}       & \\multicolumn{2}{c|}{Baseline method} \\\\                \n");

  fprintf(fout, "       &                           &                           &            &                          & succ      &    maxt      & succ      & maxt         \\\\ \\hline \\hline  \n"); 

  #if COMPILEMSVS
    fin  = fopen( "meta1\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta1/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.10, 1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta2\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta2/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.10, 1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta5\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta5/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.25, 1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta6\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta6/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.25, 1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  fprintf(fout,"\\end{tabular} \n");
  fclose( fout);
}

void createtwotables() {
  FILE* fin; FILE* fout;
  char readstring[20000];
  int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  fout = fopen( "single_table_first.tex", "w");
  fprintf(fout, "\\begin{tabular}{|r|r|r|r|r|r|r|r|r|} \\hline \\hline \n");
  fprintf(fout, "$\\mathrm{mult}$ & $\\mathrm{PROGMIN}$ & $|\\mathrm{procs}(\\Pi)|$ & $|\\tau|$ & nsg                      & \\multicolumn{2}{c|}{New method}       & \\multicolumn{2}{c|}{Baseline method} \\\\                \n");

  fprintf(fout, "       &                           &                           &            &                          & succ      &    maxt      & succ      & maxt         \\\\ \\hline \\hline  \n"); 

  #if COMPILEMSVS
    fin  = fopen( "meta1\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta1/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.10, 1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta2\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta2/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.10, 1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta3\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta3/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.40, 1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta4\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta4/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.40, 1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  fprintf(fout,"\\end{tabular} \n");
  fclose( fout);


  fout = fopen( "single_table_second.tex", "w");
  fprintf(fout, "\\begin{tabular}{|r|r|r|r|r|r|r|r|r|} \\hline \\hline \n");
  fprintf(fout, "$\\mathrm{mult}$ & $\\mathrm{PROGMIN}$ & $|\\mathrm{procs}(\\Pi)|$ & $|\\tau|$ & nsg                      & \\multicolumn{2}{c|}{New method}       & \\multicolumn{2}{c|}{Baseline method} \\\\                \n");

  fprintf(fout, "       &                           &                           &            &                          & succ      &    maxt      & succ      & maxt         \\\\ \\hline \\hline  \n"); 

  #if COMPILEMSVS
    fin  = fopen( "meta5\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta5/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.70, 1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta6\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta6/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 0.70, 1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta7\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta7/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 1.00, 1/11.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  #if COMPILEMSVS
    fin  = fopen( "meta8\\overallstatistics.txt", "r");
  #else
    fin  = fopen( "meta8/overallstatistics.txt", "r");
  #endif
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    fprintf(fout, " %4.2lf & %4.2lf    & %d      & %d         & %d                       & %.2lf       &    %6.3lf       & %.2lf        & %6.3lf          \\\\ \\hline  \n", 1.00, 1/2.0, temp1, temp2, temp3, succ_newmethod, roundup_to_ms(maxt_newmethod), succ_baselinemethod, roundup_to_ms(maxt_baselinemethod) ); 
  }
  fclose( fin);

  fprintf(fout,"\\end{tabular} \n");
  fclose( fout);
}


double getisolatedCfrompart(int partid)
{
  int index;
  for (index=1;index<=nmeasurements;index++) {
    if (measurements[index].tid==partid) {
      if ((measurements[index].cor1==0) && (measurements[index].cor2==0)  && (measurements[index].cor3==0)) {
        return measurements[index].max_exec;
      }
    }
  }
}

// In the article, obtained co-runner interference data through experiments and we saved them in a file measurements.txt
// This data is shown at the bottom of this source code file.
// This file is taken as input to the tool.

void getmeasurements()
{
  FILE* fin;
  char readstring[20000];
  int tid;
  int cor1; int cor2; int cor3;
  double max_exec; double min_exec; double avg_exec;
  fin  = fopen(  producetasksetsfrompartsfilename,  "r");
  nmeasurements = 0;
  fgets( readstring, 20000, fin); // we read the first line which show headers as text
  while (fgets( readstring, 20000, fin)!=NULL) {
    nmeasurements = nmeasurements + 1;
    if (sscanf( readstring, "%d %d %d %d %lf %lf %lf", &tid, &cor1, &cor2, &cor3, &max_exec, &min_exec, &avg_exec)!=7) {
      printf("Error when reading input file. Measurements\n");
      exit(-1);
    }
    measurements[ nmeasurements].tid  = tid;
    measurements[ nmeasurements].cor1 = cor1;
    measurements[ nmeasurements].cor2 = cor2;
    measurements[ nmeasurements].cor3 = cor3;
    measurements[ nmeasurements].max_exec = max_exec;
    measurements[ nmeasurements].min_exec = min_exec;
    measurements[ nmeasurements].avg_exec = avg_exec;
  }
  fclose( fin);
}

double getminexecalone( int i, int k)
{
  int index; int tid; int cor1; int cor2; int cor3; double max_exec; double min_exec; double avg_exec;
  for (index=1;index<=nmeasurements;index++) {
    tid  = measurements[ index].tid;
    cor1 = measurements[ index].cor1;
    cor2 = measurements[ index].cor2;
    cor3 = measurements[ index].cor3;
    max_exec = measurements[ index].max_exec;
    min_exec = measurements[ index].min_exec;
    avg_exec = measurements[ index].avg_exec;
    if ((tid!=0) && (cor1==0) && (cor2==0) && (cor3==0)) {
      if (tasks[i].segments[k].partid==tid) {
        return min_exec;
      }
    }
  }
  printf("Error in getminexecalone\n");
  exit(-1);
  return -1;
}

int aresegmentsondifferentprocessors(int i,int k,int iprime,int kprime)
{
  if (tasks[i].proc != tasks[iprime].proc)  {
    return 1;
  } else {
    return 0;
  }
}

void setcorunnerspecifications()
{
  int index; int tid; int cor1; int cor2; int cor3; double max_exec; double min_exec; double avg_exec;
  int i;                int k;
  int iprime;           int kprime;
  int iprimeprime;      int kprimeprime;
  int iprimeprimeprime; int kprimeprimeprime;
  for (index=1;index<=nmeasurements;index++) {
    tid  = measurements[ index].tid;
    cor1 = measurements[ index].cor1;
    cor2 = measurements[ index].cor2;
    cor3 = measurements[ index].cor3;
    max_exec = measurements[ index].max_exec;
    min_exec = measurements[ index].min_exec;
    avg_exec = measurements[ index].avg_exec;
    if ((tid!=0) && (cor1!=0) && (cor2==0) && (cor3==0)) {
      for (i=1;i<=ntasks;i++) {
        for (k=1;k<=tasks[i].nsegments;k++) {
          for (iprime=1;iprime<=ntasks;iprime++) {
            for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
              if ( (tasks[i].segments[k].partid==tid) && (tasks[iprime].segments[kprime].partid==cor1) ) {
                if (aresegmentsondifferentprocessors(i,k,iprime,kprime)) {
                  tasks[i].segments[k].ncorunnersetsspecified = tasks[i].segments[k].ncorunnersetsspecified + 1;
                  tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].nsegmentsincorunnerset = 1;
                  tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[1].taskindex = iprime;
                  tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[1].segmentindex = kprime;
                  tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].progresscorunnerset = getminexecalone( i, k) / max_exec;
                }
              }
            }
          }
        }
      }
    }
    if ((tid!=0) && (cor1!=0) && (cor2!=0) && (cor3==0)) {
      for (i=1;i<=ntasks;i++) {
        for (k=1;k<=tasks[i].nsegments;k++) {
          for (iprime=1;iprime<=ntasks;iprime++) {
            for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
              for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
                for (kprimeprime=1;kprimeprime<=tasks[iprimeprime].nsegments;kprimeprime++) {
                  if ( (tasks[i].segments[k].partid==tid) && (tasks[iprime].segments[kprime].partid==cor1) && (tasks[iprimeprime].segments[kprimeprime].partid==cor2) ) {
                    if ((aresegmentsondifferentprocessors(i,k,iprime,kprime)) &&
                        (aresegmentsondifferentprocessors(i,k,iprimeprime,kprimeprime)) &&
                        (aresegmentsondifferentprocessors(iprime,kprime,iprimeprime,kprimeprime))) {
                          tasks[i].segments[k].ncorunnersetsspecified = tasks[i].segments[k].ncorunnersetsspecified + 1;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].nsegmentsincorunnerset = 2;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[1].taskindex = iprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[1].segmentindex = kprime;					
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[2].taskindex = iprimeprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[2].segmentindex = kprimeprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].progresscorunnerset = getminexecalone( i, k) / max_exec;
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    if ((tid!=0) && (cor1!=0) && (cor2!=0) && (cor3!=0)) {
      for (i=1;i<=ntasks;i++) {
        for (k=1;k<=tasks[i].nsegments;k++) {
          for (iprime=1;iprime<=ntasks;iprime++) {
            for (kprime=1;kprime<=tasks[iprime].nsegments;kprime++) {
              for (iprimeprime=1;iprimeprime<=ntasks;iprimeprime++) {
                for (kprimeprime=1;kprimeprime<=tasks[iprimeprime].nsegments;kprimeprime++) {
                  for (iprimeprimeprime=1;iprimeprimeprime<=ntasks;iprimeprimeprime++) {
                    for (kprimeprimeprime=1;kprimeprimeprime<=tasks[iprimeprimeprime].nsegments;kprimeprimeprime++) {
                      if ((tasks[i].segments[k].partid==tid) && (tasks[iprime].segments[kprime].partid==cor1) && (tasks[iprimeprime].segments[kprimeprime].partid==cor2) && (tasks[iprimeprimeprime].segments[kprimeprimeprime].partid==cor3)) {
                        if ((aresegmentsondifferentprocessors(i,k,iprime,kprime)) &&
                            (aresegmentsondifferentprocessors(i,k,iprimeprime,kprimeprime)) &&
                            (aresegmentsondifferentprocessors(i,k,iprimeprimeprime,kprimeprimeprime)) &&
                            (aresegmentsondifferentprocessors(iprime,kprime,iprimeprime,kprimeprime)) &&
                            (aresegmentsondifferentprocessors(iprime,kprime,iprimeprimeprime,kprimeprimeprime)) &&
                            (aresegmentsondifferentprocessors(iprimeprime,kprimeprime,iprimeprimeprime,kprimeprimeprime))) {
                          tasks[i].segments[k].ncorunnersetsspecified = tasks[i].segments[k].ncorunnersetsspecified + 1;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].nsegmentsincorunnerset = 3;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[1].taskindex = iprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[1].segmentindex = kprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[2].taskindex = iprimeprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[2].segmentindex = kprimeprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[3].taskindex = iprimeprimeprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].segmentsincorunnerset[3].segmentindex = kprimeprimeprime;
                          tasks[i].segments[k].corunnersetsspecified[ tasks[i].segments[k].ncorunnersetsspecified ].progresscorunnerset = getminexecalone( i, k) / max_exec;
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

void printmeasurements()
{
  int index;
  for (index=1;index<=nmeasurements;index++) {
    printf("%d %d %d %d %lf %lf %lf", measurements[ index].tid, measurements[ index].cor1, measurements[ index].cor2, measurements[ index].cor3, measurements[ index].max_exec, measurements[ index].min_exec, measurements[ index].avg_exec);
  }
}

void generatetasksetforvalidation()
{
  getmeasurements();
  // task 1 is assigned to processor 1 and it consists of part 1
  // task 2 is assigned to processor 1 and it consists of part 2 and 3
  // task 3 is assigned to processor 2 and it consists of part 4
  // task 4 is assigned to processor 2 and it consists of part 5
  // task 5 is assigned to processor 3 and it consists of part 6
  // task 6 is assigned to processor 4 and it consists of part 2 and 6
  useanalysismethod = 1;
  nprocessors = 4;
  ntasks = 6;
  tasks[1].id = 1;
  tasks[1].priority = 6;
  tasks[1].proc = 1;
  tasks[1].T =  200.0;
  tasks[1].D =  200.0;
  tasks[1].nsegments = 1;
  tasks[1].segments[1].segid = 1;
  tasks[1].segments[1].C = getisolatedCfrompart(1);
  tasks[1].segments[1].pd = 0.05;
  tasks[1].segments[1].ncorunnersetsspecified = 0;
  tasks[1].segments[1].partid = 1;
  tasks[2].id = 2;
  tasks[2].priority = 5;
  tasks[2].proc = 1;
  tasks[2].T = 600.0;
  tasks[2].D = 600.0;
  tasks[2].nsegments = 2;
  tasks[2].segments[1].segid = 1;
  tasks[2].segments[1].C = getisolatedCfrompart(2);;
  tasks[2].segments[1].pd = 0.05;
  tasks[2].segments[1].ncorunnersetsspecified = 0;
  tasks[2].segments[1].partid = 2;
  tasks[2].segments[2].segid = 2;
  tasks[2].segments[2].C = getisolatedCfrompart(3);
  tasks[2].segments[2].pd = 0.05;
  tasks[2].segments[2].ncorunnersetsspecified = 0;
  tasks[2].segments[2].partid = 3;
  tasks[3].id = 3;
  tasks[3].priority = 4;
  tasks[3].proc = 2;
  tasks[3].T = 200.0;
  tasks[3].D = 200.0;
  tasks[3].nsegments = 1;
  tasks[3].segments[1].segid = 1;
  tasks[3].segments[1].C = getisolatedCfrompart(4);
  tasks[3].segments[1].pd = 0.05;
  tasks[3].segments[1].ncorunnersetsspecified = 0;
  tasks[3].segments[1].partid = 4;
  tasks[4].id = 4;
  tasks[4].priority = 3;
  tasks[4].proc = 3;
  tasks[4].T = 200.0;
  tasks[4].D = 200.0;
  tasks[4].nsegments = 1;
  tasks[4].segments[1].segid = 1;
  tasks[4].segments[1].C = getisolatedCfrompart(5);
  tasks[4].segments[1].pd = 0.05;
  tasks[4].segments[1].ncorunnersetsspecified = 0;
  tasks[4].segments[1].partid = 5;
  tasks[5].id = 5;
  tasks[5].priority = 2;
  tasks[5].proc = 4;
  tasks[5].T = 10000.0;
  tasks[5].D = 150.0;
  tasks[5].nsegments = 1;
  tasks[5].segments[1].segid = 1;
  tasks[5].segments[1].C = getisolatedCfrompart(6);
  tasks[5].segments[1].pd = 0.05;
  tasks[5].segments[1].ncorunnersetsspecified = 0;
  tasks[5].segments[1].partid = 6;
  tasks[6].id = 6;
  tasks[6].priority = 1;
  tasks[6].proc = 4;
  tasks[6].T = 500.0;
  tasks[6].D = 500.0;
  tasks[6].nsegments = 2;
  tasks[6].segments[1].segid = 1;
  tasks[6].segments[1].C = getisolatedCfrompart(2);
  tasks[6].segments[1].pd = 0.05;
  tasks[6].segments[1].ncorunnersetsspecified = 0;
  tasks[6].segments[1].partid = 2;
  tasks[6].segments[2].segid = 2;
  tasks[6].segments[2].C = getisolatedCfrompart(6);
  tasks[6].segments[2].pd = 0.05;
  tasks[6].segments[2].ncorunnersetsspecified = 0;
  tasks[6].segments[2].partid = 6;
  setcorunnerspecifications();	
  writetasksettofile("taskset_generated_from_synthetic_programs.txt");
  exit(0);
}

double get_succ_newmethod_fromfile(char* fn, int search_for_nprocessors) {
  FILE* fin; char readstring[20000]; int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  int counter; double aggregate_so_far;
  counter = 0; aggregate_so_far = 0.0;
  fin = fopen( fn, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    if (temp1==search_for_nprocessors) {
      counter++;
      aggregate_so_far = aggregate_so_far + succ_newmethod;
    }
  }
  fclose( fin);
  if (counter>=1) {
    return aggregate_so_far/counter;
  } else {
    printf("Error in get_succ_newmethod_fromfile\n"); fflush(stdout); exit(-1);
  }
}
double get_maxtime_newmethod_fromfile(char* fn, int search_for_nprocessors) {
  FILE* fin; char readstring[20000]; int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  int counter; double aggregate_so_far;
  counter = 0; aggregate_so_far = 0.0;
  fin = fopen( fn, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    if (temp1==search_for_nprocessors) {
      counter++;
      aggregate_so_far = maxdouble2( aggregate_so_far, maxt_newmethod);
    }
  }
  fclose( fin);
  if (counter>=1) {
    return aggregate_so_far;
  } else {
    printf("Error in get_maxtime_newmethod_fromfile\n"); fflush(stdout); exit(-1);
  }
}
double get_succ_baselinemethod_fromfile(char* fn, int search_for_nprocessors) {
  FILE* fin; char readstring[20000]; int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  int counter; double aggregate_so_far;
  counter = 0; aggregate_so_far = 0.0;
  fin = fopen( fn, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    if (temp1==search_for_nprocessors) {
      counter++;
      aggregate_so_far = aggregate_so_far + succ_baselinemethod;
    }
  }
  fclose( fin);
  if (counter>=1) {
    return aggregate_so_far/counter;
  } else {
    printf("Error in get_succ_baselinemethod_fromfile\n"); fflush(stdout); exit(-1);
  }
}
double get_maxtime_baselinemethod_fromfile(char* fn, int search_for_nprocessors) {
  FILE* fin; char readstring[20000]; int temp1; int temp2; int temp3; 
  double succ_newmethod;     double mint_newmethod;     double maxt_newmethod;
  double succ_baselinemethod; double mint_baselinemethod; double maxt_baselinemethod;
  int counter; double aggregate_so_far;
  counter = 0; aggregate_so_far = 0.0;
  fin = fopen( fn, "r");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    if (temp1==search_for_nprocessors) {
      counter++;
      aggregate_so_far = maxdouble2( aggregate_so_far, maxt_baselinemethod);
    }
  }
  fclose( fin);
  if (counter>=1) {
    return aggregate_so_far;
  } else {
    printf("Error in get_maxtime_baselinemethod_fromfile\n"); fflush(stdout); exit(-1);
  }
}

void compute_aggregate_statistics(int filter, int selectedmetaindex) {
  FILE* fout; double aggregate_so_far; int counter; int metaindex; char metadir[20000];

  if (filter) { fout = fopen( "succ_newmethod_filtered.txt", "w"); } else { fout = fopen( "succ_newmethod.txt", "w"); }
  for (nprocessors=2;nprocessors<=8;nprocessors++) {
    counter = 0; aggregate_so_far = 0.0;
    for (metaindex=1;metaindex<=400;metaindex++) {
      sprintf( metadir, "meta%d", metaindex);
      mymakedirectory(metadir);
      mychdir(metadir);
      if ((!filter) || (selectedmetaindex==metaindex)) {
        aggregate_so_far = aggregate_so_far + get_succ_newmethod_fromfile("overallstatistics.txt", nprocessors);
        counter++;
      }
      mychdir("..");
    }
    fprintf(fout, "%d %lf\n", nprocessors, aggregate_so_far/counter);
  }
  fclose( fout);

  if (filter) { fout = fopen( "maxtime_required_newmethod_filtered.txt", "w"); } else { fout = fopen( "maxtime_required_newmethod.txt", "w"); }
  for (nprocessors=2;nprocessors<=8;nprocessors++) {
    counter = 0; aggregate_so_far = 0.0;
    for (metaindex=1;metaindex<=400;metaindex++) {
      sprintf( metadir, "meta%d", metaindex);
      mymakedirectory(metadir);
      mychdir(metadir);
      if ((!filter) || (selectedmetaindex==metaindex)) {
        aggregate_so_far = maxdouble2( aggregate_so_far, get_maxtime_newmethod_fromfile("overallstatistics.txt", nprocessors) );
        counter++;
      }
      mychdir("..");
    }
    fprintf(fout, "%d %lf\n", nprocessors, aggregate_so_far);
  }
  fclose( fout);

  if (filter) { fout = fopen( "succ_baselinemethod_filtered.txt", "w"); } else { fout = fopen( "succ_baselinemethod.txt", "w"); }
  for (nprocessors=2;nprocessors<=8;nprocessors++) {
    counter = 0; aggregate_so_far = 0.0;
    for (metaindex=1;metaindex<=400;metaindex++) {
      sprintf( metadir, "meta%d", metaindex);
      mymakedirectory(metadir);
      mychdir(metadir);
      if ((!filter) || (selectedmetaindex==metaindex)) {
        aggregate_so_far = aggregate_so_far + get_succ_baselinemethod_fromfile("overallstatistics.txt", nprocessors);
        counter++;
      }
      mychdir("..");
    }
    fprintf(fout, "%d %lf\n", nprocessors, aggregate_so_far/counter);
  }
  fclose( fout);

  if (filter) { fout = fopen( "maxtime_required_baselinemethod_filtered.txt", "w"); } else { fout = fopen( "maxtime_required_baselinemethod.txt", "w"); }
  for (nprocessors=2;nprocessors<=8;nprocessors++) {
    counter = 0; aggregate_so_far = 0.0;
    for (metaindex=1;metaindex<=400;metaindex++) {
      sprintf( metadir, "meta%d", metaindex);
      mymakedirectory(metadir);
      mychdir(metadir);
      if ((!filter) || (selectedmetaindex==metaindex)) {
        aggregate_so_far = maxdouble2( aggregate_so_far, get_maxtime_baselinemethod_fromfile("overallstatistics.txt", nprocessors) );
        counter++;
      }
      mychdir("..");
    }
    fprintf(fout, "%d %lf\n", nprocessors, aggregate_so_far);
  }
  fclose( fout);  
}

void do_part_for_create_text_for_appendix(FILE* fout, int metaindex, double mul, double PROGMIN) {
    char fnwithdir[20000];
    char readstring[20000];
    FILE* fin;
    int counter; int startdataindex; int finishdataindex; int middlepoint;
    fprintf(fout, "\\begin{table*}[t]\n"); 
    #if COMPILEMSVS
      sprintf(fnwithdir,"meta%d\\overallstatistics.tex", metaindex);
    #else
      sprintf(fnwithdir,"meta%d/overallstatistics.tex", metaindex);
    #endif
    fprintf(fout, "\\scalebox{.7}{\n"); 

    startdataindex = 0; finishdataindex = 0;
    counter = 0;
    fin  = fopen( fnwithdir, "r");
    while (fgets( readstring, 20000, fin)!=NULL) {
      if (strncmp(readstring,"         &",10)==0) {
        startdataindex = counter+1;
      }
      if (strncmp(readstring,"\\end",4)==0) {
        finishdataindex = counter-1;
      }
      counter++;
    }
    fclose( fin);

    middlepoint = (startdataindex + finishdataindex)/2;

    counter = 0;
    fin  = fopen( fnwithdir, "r");
    while (fgets( readstring, 20000, fin)!=NULL) {
      if ((middlepoint<counter) && (counter<=finishdataindex)) { 
        ;
      } else {
        fprintf(fout, "%s", readstring );
      }
      counter++;
    }
    fclose( fin);

    counter = 0;
    fin  = fopen( fnwithdir, "r");
    while (fgets( readstring, 20000, fin)!=NULL) {
      if ((startdataindex<=counter) && (counter<=middlepoint)) { 
        ;
      } else {
        fprintf(fout, "%s", readstring );
      }
      counter++;
    }
    fclose( fin);

    fprintf(fout, "}\n"); 
    fprintf(fout, "\\caption{$\\mathrm{mul}$=%4.2lf. $\\mathrm{PROGMIN}$=%4.2lf. Results from our evaluation of our new schedulability test against the baseline schedulability test on randomly generated tasksets. Each row shows one experimental setup and reports the parameters ($\\mathrm{mul}$,$\\mathrm{PROGMIN}$,$|\\mathrm{procs}(\\Pi)|$,$|\\tau|$, and $\\mathrm{nsg}$) that influence the experimental setup and the performance metrics of the algorithm ($\\mathrm{succ}$, $\\mathrm{maxt}$) for this experimental setup. In each experimental setup, 100 tasksets are evaluated. $\\mathrm{nsg}$ indicates the number of segments per task. $\\mathrm{succ}$ indicates the success ratio. $\\mathrm{maxt}$ indicates the largest observed running time of the schedulability test. All times are measured in seconds.}\n", mul, PROGMIN);
    fprintf(fout, "\\label{table:table_with_all_experimental results_appendixb_table_%d}\n", metaindex);
    fprintf(fout, "\\end{table*}\n");
    fprintf(fout, "\\clearpage\n");
    fprintf(fout, "\n");
}
void create_text_for_appendix() {
  FILE* fout; int loc_metaindex; double r; double mult;
  fout = fopen( "appendix.tex", "w");
  for (loc_metaindex=1;loc_metaindex<=400;loc_metaindex++) {
    if (should_this_metaindex_be_included(loc_metaindex)) {
      get_mul_and_r_from_metaindex( loc_metaindex, &mult, &r);
      do_part_for_create_text_for_appendix( fout, loc_metaindex, mult, r);
    }
  }
  fclose( fout);
}

void createplot(int x, int y) {
    double r; double mult;
    FILE* fout;
    char gp_fn[20000]; char mycommand[20000];
    sprintf(gp_fn,"commandgnuplot_%d_%d.gnuplot", x,y);
    fout = fopen( gp_fn, "w");

    fprintf(fout,"set xtics font 'Times-New-Roman,20'\n");
    fprintf(fout,"set ytics font 'Times-New-Roman,20'\n");
    fprintf(fout,"set title font 'Times-New-Roman,20'\n");

    if (x==0) { fprintf(fout,"set yrange [0.0078125:1024]\n"); }
    if (x==1) { fprintf(fout,"set yrange [0.000000:   1]\n"); }
    fprintf(fout,"set terminal pdf\n");

    if ((x==0) && (y==0)) { fprintf(fout,"set output 'maxtime_required.pdf'\n"); }
    if ((x==0) && (y==1)) { fprintf(fout,"set output 'maxtime_required_filtered.pdf'\n"); }
    if ((x==1) && (y==0)) { fprintf(fout,"set output 'succ.pdf'\n"); }
    if ((x==1) && (y==1)) { fprintf(fout,"set output 'succ_filtered.pdf'\n"); }

    fprintf(fout,"set nokey\n");

    fprintf(fout,"set term pdfcairo font 'Times-New-Roman,12'\n");  // we do this so that the title fits on a single line

    get_mul_and_r_from_metaindex( 8, &mult, &r);
      if ((x==0) && (y==0)) { fprintf(fout,"set title 'Max time as function of #processors'\n"); }
      if ((x==0) && (y==1)) { fprintf(fout,"set title 'Max time as function of #processors. mul=%4.2lf PROGMIN=%4.2lf'\n", mult, r); }
      if ((x==1) && (y==0)) { fprintf(fout,"set title 'Success ratio as function of #processors'\n"); }
      if ((x==1) && (y==1)) { fprintf(fout,"set title 'Success ratio as function of #processors. mul=%4.2lf PROGMIN=%4.2lf'\n", mult, r); }


    if  (x==0) { fprintf(fout,"set logscale y 2\n"); }

    if ((x==0) && (y==0)) { fprintf(fout,"plot [2:8] 'maxtime_required_newmethod.txt' with points pt 7 title 'Our method', 'maxtime_required_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((x==0) && (y==1)) { fprintf(fout,"plot [2:8] 'maxtime_required_newmethod_filtered.txt' with points pt 7 title 'Our method', 'maxtime_required_baselinemethod_filtered.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((x==1) && (y==0)) { fprintf(fout,"plot [2:8] 'succ_newmethod.txt' with points pt 7 title 'Our method', 'succ_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((x==1) && (y==1)) { fprintf(fout,"plot [2:8] 'succ_newmethod_filtered.txt' with points pt 7 title 'Our method', 'succ_baselinemethod_filtered.txt' with points pt 12 title 'Baseline method'\n"); }

  fclose( fout);
  sprintf( mycommand,"gnuplot %s", gp_fn);
  system( mycommand);
}

void create_large_file_with_all_statistics() {
  FILE* fout; FILE* fin; double mult; double r;
  char readstring[20000];
  char metadir[20000];
  int temp1; int temp2; int temp3; 
  double succ_newmethod;      double maxt_newmethod;
  double succ_baselinemethod; double maxt_baselinemethod;
  int metaindex;

  fout = fopen( "allstatistics.txt", "w");
  for (metaindex=1;metaindex<=400;metaindex++) {
    if (should_this_metaindex_be_included(metaindex)) {
      sprintf( metadir, "meta%d", metaindex);
      mychdir(metadir);
      get_mul_and_r_from_metaindex( metaindex, &mult, &r);
      fin = fopen( "overallstatistics.txt", "r");
      while (fgets( readstring, 20000, fin)!=NULL) {
        sscanf( readstring, "%d %d %d %lf %lf %lf %lf", &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
        if (should_this_metaindex_be_included(metaindex)) { // this will be true but we keep it for historical reasons
          fprintf( fout, "%lf %lf %s", mult, r, readstring);
        }
      }
      fclose( fin);
      mychdir("..");
    }
  }
  fclose( fout);
}

int almostequal(double t1, double t2) {
  double absdiff; double reldiff;
  absdiff = fabs(t1-t2);
  if (absdiff==0.0) {
    return 1;
  }
  reldiff = absdiff/fabs(t1);
  if (reldiff<0.000001) {
    return 1;
  } else {
    return 0;
  }
}

double get_average_of_col_x_for_rows_where_col_y_is_z(char* fn, int col_id_from_which_data_is_computed, int col_id_for_selection, double value_for_selection) {
  FILE* fin;
  char readstring[20000];
  double local_mult; double local_r; int temp1; int temp2; int temp3; 
  double succ_newmethod;      double maxt_newmethod;
  double succ_baselinemethod; double maxt_baselinemethod;
  double newvalue;
  double aggregate_so_far; int counter;
  int selected;

  counter = 0; aggregate_so_far = 0.0;
  fin = fopen( fn, "rt");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%lf %lf %d %d %d %lf %lf %lf %lf", &local_mult, &local_r, &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    selected = 0;
    if ((col_id_for_selection==1) && (almostequal(local_mult,value_for_selection))) { selected = 1; }
    if ((col_id_for_selection==2) && (almostequal(local_r,value_for_selection)))    { selected = 1; }
    if ((col_id_for_selection==3) && (almostequal(temp1,value_for_selection)))      { selected = 1; }
    if ((col_id_for_selection==4) && (almostequal(temp2,value_for_selection)))      { selected = 1; }
    if ((col_id_for_selection==5) && (almostequal(temp3,value_for_selection)))      { selected = 1; }
    
    if (selected) {
      newvalue = -1;
      if (col_id_from_which_data_is_computed==6) { newvalue = succ_newmethod; }
      if (col_id_from_which_data_is_computed==7) { newvalue = maxt_newmethod; }
      if (col_id_from_which_data_is_computed==8) { newvalue = succ_baselinemethod; }
      if (col_id_from_which_data_is_computed==9) { newvalue = maxt_baselinemethod; }
      if (newvalue==-1) { printf("Error in get_avg\n"); exit(0); } 
      counter = counter + 1;
      aggregate_so_far = aggregate_so_far + newvalue;
    }
  }
  fclose( fin);
  if (counter==0) { printf("Error in get_average_of_col_x_for_rows_where_col_y_is_z. %d %d %lf\n", col_id_from_which_data_is_computed,col_id_for_selection,value_for_selection); exit(0); }
  return aggregate_so_far/counter;
}

double get_max_of_col_x_for_rows_where_col_y_is_z(char* fn, int col_id_from_which_data_is_computed, int col_id_for_selection, double value_for_selection) {
  FILE* fin;
  char readstring[20000];
  double local_mult; double local_r; int temp1; int temp2; int temp3; 
  double succ_newmethod;      double maxt_newmethod;
  double succ_baselinemethod; double maxt_baselinemethod;
  double newvalue;
  double aggregate_so_far; int counter;
  int selected;

  counter = 0; aggregate_so_far = 0.0;
  fin = fopen( fn, "rt");
  while (fgets( readstring, 20000, fin)!=NULL) {
    sscanf( readstring, "%lf %lf %d %d %d %lf %lf %lf %lf", &local_mult, &local_r, &temp1, &temp2, &temp3, &succ_newmethod, &maxt_newmethod, &succ_baselinemethod, &maxt_baselinemethod );
    selected = 0;
    if ((col_id_for_selection==1) && (almostequal(local_mult,value_for_selection))) { selected = 1; }
    if ((col_id_for_selection==2) && (almostequal(local_r,value_for_selection)))    { selected = 1; }
    if ((col_id_for_selection==3) && (almostequal(temp1,value_for_selection)))      { selected = 1; }
    if ((col_id_for_selection==4) && (almostequal(temp2,value_for_selection)))      { selected = 1; }
    if ((col_id_for_selection==5) && (almostequal(temp3,value_for_selection)))      { selected = 1; }
    
    if (selected) {
      newvalue = -1;
      if (col_id_from_which_data_is_computed==6) { newvalue = succ_newmethod; }
      if (col_id_from_which_data_is_computed==7) { newvalue = maxt_newmethod; }
      if (col_id_from_which_data_is_computed==8) { newvalue = succ_baselinemethod; }
      if (col_id_from_which_data_is_computed==9) { newvalue = maxt_baselinemethod; }
      if (newvalue==-1) { printf("Error in get_avg\n"); exit(0); } 
      counter = counter + 1;
      aggregate_so_far = maxdouble2( aggregate_so_far, newvalue);
    }
  }
  fclose( fin);
  if (counter==0) { printf("Error in get_max_of_col_x_for_rows_where_col_y_is_z\n"); exit(0); }
  return aggregate_so_far;
}

void create_datafiles_for_each_of_the_eight_plots() {
  FILE* fout;
  int iterator;
  double local_mul; double local_PROGMIN; int local_nprocessors; int local_ntasks;

  fout = fopen( "first_of_eight_newmethod.txt", "w");
  for (iterator=2;iterator<=20;iterator++) { // if we choose iterator=1, then local_mul=0.1. For this case, all systems are schedulable. This is because systems with mult<=PROGMIN are schedulable.
    local_mul = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_mul, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 6, 1, local_mul));
  }
  fclose( fout);

  fout = fopen( "first_of_eight_baselinemethod.txt", "w");
  for (iterator=2;iterator<=20;iterator++) {
    local_mul = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_mul, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 8, 1, local_mul));
  }
  fclose( fout);

  fout = fopen( "second_of_eight_newmethod.txt", "w");
  for (iterator=1;iterator<=19;iterator++) {
    local_PROGMIN = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_PROGMIN, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 6, 2, local_PROGMIN));
  }
  fclose( fout);

  fout = fopen( "second_of_eight_baselinemethod.txt", "w");
  for (iterator=1;iterator<=19;iterator++) {
    local_PROGMIN = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_PROGMIN, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 8, 2, local_PROGMIN));
  }
  fclose( fout);

  fout = fopen( "third_of_eight_newmethod.txt", "w");
  for (local_nprocessors=2;local_nprocessors<=8;local_nprocessors++) {
    fprintf( fout, "%d %lf\n", local_nprocessors, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 6, 3, local_nprocessors));
  }
  fclose( fout);

  fout = fopen( "third_of_eight_baselinemethod.txt", "w");
  for (local_nprocessors=2;local_nprocessors<=8;local_nprocessors++) {
    fprintf( fout, "%d %lf\n", local_nprocessors, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 8, 3, local_nprocessors));
  }
  fclose( fout);

  fout = fopen( "fourth_of_eight_newmethod.txt", "w");
  for (local_ntasks=2;local_ntasks<=16;local_ntasks+=2) {
    fprintf( fout, "%d %lf\n", local_ntasks, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 6, 4, local_ntasks));
  }
  fclose( fout);

  fout = fopen( "fourth_of_eight_baselinemethod.txt", "w");
  for (local_ntasks=2;local_ntasks<=16;local_ntasks+=2) {
    fprintf( fout, "%d %lf\n", local_ntasks, get_average_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 8, 4, local_ntasks));
  }
  fclose( fout);

  fout = fopen( "fifth_of_eight_newmethod.txt", "w");
  for (iterator=2;iterator<=20;iterator++) {
    local_mul = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_mul, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 7, 1, local_mul));
  }
  fclose( fout);

  fout = fopen( "fifth_of_eight_baselinemethod.txt", "w");
  for (iterator=2;iterator<=20;iterator++) {
    local_mul = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_mul, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 9, 1, local_mul));
  }
  fclose( fout);

  fout = fopen( "sixth_of_eight_newmethod.txt", "w");
  for (iterator=1;iterator<=19;iterator++) {
    local_PROGMIN = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_PROGMIN, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 7, 2, local_PROGMIN));
  }
  fclose( fout);

  fout = fopen( "sixth_of_eight_baselinemethod.txt", "w");
  for (iterator=1;iterator<=19;iterator++) {
    local_PROGMIN = iterator*0.05;
    fprintf( fout, "%lf %lf\n", local_PROGMIN, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 9, 2, local_PROGMIN));
  }
  fclose( fout);

  fout = fopen( "seventh_of_eight_newmethod.txt", "w");
  for (local_nprocessors=2;local_nprocessors<=8;local_nprocessors++) {
    fprintf( fout, "%d %lf\n", local_nprocessors, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 7, 3, local_nprocessors));
  }
  fclose( fout);

  fout = fopen( "seventh_of_eight_baselinemethod.txt", "w");
  for (local_nprocessors=2;local_nprocessors<=8;local_nprocessors++) {
    fprintf( fout, "%d %lf\n", local_nprocessors, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 9, 3, local_nprocessors));
  }
  fclose( fout);

  fout = fopen( "eight_of_eight_newmethod.txt", "w");
  for (local_ntasks=2;local_ntasks<=16;local_ntasks+=2) {
    fprintf( fout, "%d %lf\n", local_ntasks, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 7, 4, local_ntasks));
  }
  fclose( fout);

  fout = fopen( "eight_of_eight_baselinemethod.txt", "w");
  for (local_ntasks=2;local_ntasks<=16;local_ntasks+=2) {
    fprintf( fout, "%d %lf\n", local_ntasks, get_max_of_col_x_for_rows_where_col_y_is_z("allstatistics.txt", 9, 4, local_ntasks));
  }
  fclose( fout);
}

// SR=0 means that the plot is about success ratio; otherwise it is 1 and it means maxt.
// void createplot_one_of_the_eight(int SR, int x, int y) {
void createplot_one_of_the_eight(int SR, int y, int x) {
    double r; double mult;
    FILE* fout;
    char gp_fn[20000]; char mycommand[20000];
    sprintf(gp_fn,"commandgnuplot_%d_%d_%d.gnuplot", SR, y,x);
    fout = fopen( gp_fn, "w");

    fprintf(fout,"set xtics font 'Times-New-Roman,20'\n");
    fprintf(fout,"set ytics font 'Times-New-Roman,20'\n");
    fprintf(fout,"set title font 'Times-New-Roman,20'\n");

    if (SR==0) { fprintf(fout,"set yrange [0.000000000:   1]\n"); }
    // if (SR==1) { fprintf(fout,"set yrange [0.0.0001:1024]\n"); }
    // if (SR==1) { fprintf(fout,"set yrange [0.0001:1024]\n"); }
    // if (SR==1) { fprintf(fout,"set yrange [0.0001:1200]\n"); }
    if (SR==1) { fprintf(fout,"set yrange [0.00005:1200]\n"); }
    fprintf(fout,"set terminal pdf\n");

    if ((SR==0) && (y==0) && (x==0)) { fprintf(fout,"set output 'succ_mul.pdf'\n"); }
    if ((SR==0) && (y==0) && (x==1)) { fprintf(fout,"set output 'succ_PROGMIN.pdf'\n"); }
    if ((SR==0) && (y==1) && (x==0)) { fprintf(fout,"set output 'succ_nprocessors.pdf'\n"); }
    if ((SR==0) && (y==1) && (x==1)) { fprintf(fout,"set output 'succ_ntasks.pdf'\n"); }
    if ((SR==1) && (y==0) && (x==0)) { fprintf(fout,"set output 'maxt_mul.pdf'\n"); }
    if ((SR==1) && (y==0) && (x==1)) { fprintf(fout,"set output 'maxt_PROGMIN.pdf'\n"); }
    if ((SR==1) && (y==1) && (x==0)) { fprintf(fout,"set output 'maxt_nprocessors.pdf'\n"); }
    if ((SR==1) && (y==1) && (x==1)) { fprintf(fout,"set output 'maxt_ntasks.pdf'\n"); }

    fprintf(fout,"set nokey\n");

    fprintf(fout,"set term pdfcairo font 'Times-New-Roman,12'\n");  // we do this so that the title fits on a single line

    if (SR==1) { fprintf(fout,"set logscale y 2\n"); }

    if ((SR==0) && (y==0) && (x==0)) { fprintf(fout,"plot [0:1] 'first_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'first_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((SR==0) && (y==0) && (x==1)) { fprintf(fout,"plot [0:1] 'second_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'second_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((SR==0) && (y==1) && (x==0)) { fprintf(fout,"plot [2:8] 'third_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'third_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((SR==0) && (y==1) && (x==1)) { fprintf(fout,"plot [2:16] 'fourth_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'fourth_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((SR==1) && (y==0) && (x==0)) { fprintf(fout,"plot [0:1] 'fifth_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'fifth_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((SR==1) && (y==0) && (x==1)) { fprintf(fout,"plot [0:1] 'sixth_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'sixth_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((SR==1) && (y==1) && (x==0)) { fprintf(fout,"plot [2:8] 'seventh_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'seventh_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }
    if ((SR==1) && (y==1) && (x==1)) { fprintf(fout,"plot [2:16] 'eight_of_eight_newmethod.txt' with points pt 7 title 'Our method', 'eight_of_eight_baselinemethod.txt' with points pt 12 title 'Baseline method'\n"); }

  fclose( fout);
  sprintf( mycommand,"gnuplot %s", gp_fn);
  system( mycommand);
}

void create_theplots_for_each_of_the_eight_plots() {
  createplot_one_of_the_eight( 0, 0, 0);
  createplot_one_of_the_eight( 0, 0, 1);
  createplot_one_of_the_eight( 0, 1, 0);
  createplot_one_of_the_eight( 0, 1, 1);
  createplot_one_of_the_eight( 1, 0, 0);
  createplot_one_of_the_eight( 1, 0, 1);
  createplot_one_of_the_eight( 1, 1, 0);
  createplot_one_of_the_eight( 1, 1, 1);
}

void create_eight_plots() {
  create_large_file_with_all_statistics();
  create_datafiles_for_each_of_the_eight_plots();
  create_theplots_for_each_of_the_eight_plots();
}

void writedoubletofile(char* fn, double t) {
  FILE* fout;
  fout = fopen( fn, "w");
  fprintf( fout, "%lf", t);
  fclose( fout);
}

// this returns 0 if there was a system that took more than 1000 seconds;
// otherwise it returns 1.
int do_metathing_for_generating_table_for_schedulability(double maxtime_threshold) {
  int index1; int index2; int iterator; double mult; double PROGMIN;
  int local_counter; char localfn[20000]; double max_time_so_far;
  local_counter = 1;
  max_time_so_far = 0.0;
  for (nsg=2;nsg>=1;nsg--) { // we do it in decreasing order in order to get early termination in case of large time
    for (index1=1;index1<=20;index1++) {
      for (index2=1;index2<=20;index2++) {
        if (index1>index2) {
          for (iterator=1;iterator<=MAX_ITERATOR_IN_BATCH;iterator++) {
            useanalysismethod = 1;
            mult   = index1*0.05;
            PROGMIN = index2*0.05;
            assignTDCoftasks();
            sorttasksinDMorderandassignpriorities();
            assigntaskstoprocessors();
            scale_taskset_so_that_it_is_critically_schedulable_without_co_runner_interference();
            scale_taskset_by_factor( mult); 
            assigninitialcorunnerdependencies( PROGMIN);
            rearrangecorunnerdependencies();
            recomputepd(PROGMIN);
            sprintf( localfn, "taskset_%d_nsg%d_index1_%d_index2_%d.txt", local_counter, nsg, index1, index2);
            sprintf( outputfilename, "taskset_%d_nsg%d_index1_%d_index2_%d_results_from_analysis.txt", local_counter, nsg, index1, index2);
            // writetasksettofile(localfn); // we do not need to write and then read the taskset to/from file.

            // readtasksetfromfile(localfn);
            determineschedulabilityandcomputeresponsetimes();
            writeresponsetimestofile(outputfilename);

            max_time_so_far = maxdouble2(timerequiredforschedulabilityanalysis_newmethod,max_time_so_far);
            if (timerequiredforschedulabilityanalysis_newmethod>maxtime_threshold) {
              return 0;
            }
            local_counter++;
          }
        }
      }
    }
  }
  writedoubletofile("maxtimefound.txt", max_time_so_far);
  return 1;
}

#define XDIM 11
#define YDIM 7

int compute_index_from_x_and_y(int x, int y) {
  return y*XDIM+x;
}

int power2(int n) {
  if (n==0) { return 1; }
  else { return 2*power2(n-1); }
}

// When running this function, there may be failures because of insufficient memory. We treat that as if the running time exceeds the threshold. And then run again with new cells in the table.
void create_plots_that_shows_scalability_as_table() {
  int resultarray[XDIM*YDIM];
  int index; int x; int y; int flag;
  FILE* fout;
  char tempdirname[20000];
  for (index=0;index<XDIM*YDIM;index++) {
    resultarray[index] = 0;
  }
  for (x=0;x<=6;x++) {
    for (y=3;y<YDIM;y++) {
      resultarray[index] = 1;
    }
  }
  flag = 1;
  for (x=0;x<=6;x++) {
    y = 4; flag = 1;
    while ((y<YDIM) && (flag)) {
      ntasks = power2(y+1);
      nprocessors = x+2;
      
      sprintf( tempdirname, "evaluating_scalability%d_%d", x,y);
      mymakedirectory( tempdirname);
      mychdir(tempdirname);

      flag = do_metathing_for_generating_table_for_schedulability(1000.0);
      if (flag) {
        index = compute_index_from_x_and_y(x, y);
        resultarray[index] = 1;
      }
      mychdir("..");
      y++;
    }
  }
  for (x=7;x<XDIM;x++) {
    y = 0; flag = 1;
    while ((y<YDIM) && (flag)) {
      ntasks = power2(y+1);
      nprocessors = x+2;
      
      sprintf( tempdirname, "evaluating_scalability%d_%d", x,y);
      mymakedirectory( tempdirname);
      mychdir(tempdirname);

      flag = do_metathing_for_generating_table_for_schedulability(1000.0);
      if (flag) {
        index = compute_index_from_x_and_y(x, y);
        resultarray[index] = 1;
      }
      mychdir("..");
      y++;
    }
  }

  fout = fopen( "table_that_shows_scalability", "w");

  fprintf( fout, "\\begin{table*}[t]\n");
  fprintf( fout, "\\centering\n");
  fprintf( fout, "\\begin{tabular}{|r|r|r|r|r|r|r|r|r|r|r|r|r|r|r|r|} \\hline\n"); 
  fprintf( fout, "\\backslashbox{$|\\tau|$}{$|\\mathrm{procs}(\\Pi)|$} & 2                    & 3                    & 4                   & 5                    & 6                   & 7                   & 8                   & 9                    & 10 & 11 & 12 & 13 & 14 & 15 & 16 \\\\ \\hline\n"); 
  for (y=0;y<YDIM;y++) {
    fprintf( fout, "   %d ", power2(y+1));
    for (x=0;x<XDIM;x++) {
      index = compute_index_from_x_and_y(x, y);
      if (resultarray[index]) {
        fprintf( fout, " & \\cellcolor{gray!25} ");
      } else {
        fprintf( fout, " &                     ");
      }
      fprintf( fout, " \\\\");
    }
  }
  fprintf( fout, "\\hline\n");
  fprintf( fout, "\\end{tabular}\n");
  fprintf( fout, "\\caption{Systems for which our method required at most 1000 seconds.}\n");
  fprintf( fout, "\\label{table:table_showing_scalability}\n");
  fprintf( fout, "\\end{table*}\n");

  fclose( fout); 
}

int main( int argc, char *argv[], char *envp[]) {
  int metaindex; char metadir[20000];
  enablelogging = 0;
  allocate_global_variables();
  initialize_random_generator();
  parsearguments(argc, argv, envp);

  if (metathing==1) {
    for (metaindex=1;metaindex<=400;metaindex++) {
      if (should_this_metaindex_be_included(metaindex)) {
        sprintf( metadir, "meta%d", metaindex);
        mymakedirectory(metadir);
        mychdir(metadir);
        write_mult_and_PROGMIN_to_file_based_on_metaindex("mult_and_PROGMIN.txt", metaindex);
        do_metathing_generate_experiments(metaindex);
        mychdir("..");
      }
    }
    for (metaindex=1;metaindex<=400;metaindex++) {
      if (should_this_metaindex_be_included(metaindex)) {
        sprintf( metadir, "meta%d", metaindex);
        mymakedirectory(metadir);
        mychdir(metadir);
        do_metathing_run_experiments(metaindex);
        mychdir("..");
      }
    }
    create_text_for_appendix();
    create_eight_plots();
    create_plots_that_shows_scalability_as_table();
    exit(0);
  }
  if (producetasksetsfromparts==1) {
    generatetasksetforvalidation();
    exit(0);
  }
  if (generate_experiments==1) {
    do_generate_experiments(1.0/2.0);
  }
  if (run_experiments==1) {
    do_run_experiments();
  }
  if (generate_statistics==1) {
    do_generate_statistics();
  }
  readtasksetfromfile( inputfilename );
  if (determineschedulabilityandcomputeresponsetimes()==1) {
    printf("Task set is schedulable.\n");
  } else {
    printf("Cannot guarantee schedulability.\n");
  }
  writeresponsetimestofile(outputfilename);
  deallocate_global_variables();
  return 0;
}

/*
tid	cor1	cor2	cor3	max_exec	min_exec	avg_exec
1	0	0	0	58	57.94	57.98
1	1	0	0	103.19	98.24	98.63
1	2	0	0	92.12	84.89	91.61
1	3	0	0	88.22	88.02	88.13
1	4	0	0	85.34	81.75	84.48
1	5	0	0	85.92	82.66	83.02
1	6	0	0	81.24	80.94	81.02
1	1	1	0	99.67	99.26	99.49
1	1	2	0	105.09	98.52	104.19
1	1	3	0	93.56	92.22	92.74
1	1	4	0	101.86	100.25	100.5
1	1	5	0	90.39	89.41	90.18
1	1	6	0	100.92	98.42	99.72
1	2	2	0	92.33	91.63	91.96
1	2	3	0	98.92	98.67	98.78
1	2	4	0	88.95	88.33	88.69
1	2	5	0	113.53	94.44	95.98
1	2	6	0	86.46	85.61	85.99
1	3	3	0	96.84	96.08	96.55
1	3	4	0	86.86	86.39	86.63
1	3	5	0	97.1	84.93	92.38
1	3	6	0	84.65	83.75	84.16
1	4	4	0	93.31	91.94	92.92
1	4	5	0	85.93	85.12	85.54
1	4	6	0	92.25	89.26	90.02
1	5	5	0	82.96	82.29	82.66
1	5	6	0	89.1	88.22	88.76
1	6	6	0	81.58	80.28	80.64
1	1	1	1	107.96	105.7	106.98
1	1	1	2	104.06	101.68	102.74
1	1	1	3	102.68	90.34	100.15
1	1	1	4	101.08	97.88	99.51
1	1	1	5	102.35	98.86	100.65
1	1	1	6	99.71	96	97.57
1	1	2	2	101.54	94.04	99.76
1	1	2	3	99.92	90.92	97.65
1	1	2	4	101.93	97.59	99.43
1	1	2	5	98.33	95.32	96.52
1	1	2	6	96.18	94.57	95.45
1	1	3	3	99.33	96.23	97.23
1	1	3	4	99.78	97.01	98.18
1	1	3	5	96.16	93.26	94.95
1	1	3	6	95.37	93.16	94.03
1	1	4	4	96.18	93.92	94.82
1	1	4	5	97.58	94.78	95.73
1	1	4	6	93.83	92.11	92.74
1	1	5	5	102.06	92.08	93.29
1	1	5	6	92.68	91.3	91.85
1	1	6	6	95.91	92.39	93.23
1	2	2	2	99.09	96.47	97.68
1	2	2	3	100.02	95.76	96.63
1	2	2	4	96.42	94.22	95.23
1	2	2	5	98.75	95.35	96.37
1	2	2	6	94.31	92.42	93.35
1	2	3	3	95.84	94.47	95
1	2	3	4	94.42	88.76	93.15
1	2	3	5	95.33	94.29	94.87
1	2	3	6	92.51	88.82	91.65
1	2	4	4	93.41	91.76	92.55
1	2	4	5	92.24	91.31	91.65
1	2	4	6	96.66	91.57	93.56
1	2	5	5	92.52	90.26	90.77
1	2	5	6	90.03	89.11	89.58
1	2	6	6	90.21	88.25	88.97
1	3	3	3	96.92	94.22	95.5
1	3	3	4	93.21	88.42	92.02
1	3	3	5	92.21	90.44	91.3
1	3	3	6	91.22	89.23	90.4
1	3	4	4	94.13	92.98	93.53
1	3	4	5	90.97	88.79	90.03
1	3	4	6	89.8	85.53	89.01
1	3	5	5	89.54	88.81	89.23
1	3	5	6	92.09	89.55	90.78
1	3	6	6	88.27	86.69	87.62
1	4	4	4	90.98	89.25	90.13
1	4	4	5	89.91	87.69	89.06
1	4	4	6	98.51	89.64	90.93
1	4	5	5	89.17	87.36	88.25
1	4	5	6	87.71	86.14	87.08
1	4	6	6	87.25	83.4	86.33
1	5	5	5	93.42	87.98	89.39
1	5	5	6	86.95	85.33	86.24
1	5	6	6	86.06	84.92	85.65
1	6	6	6	85.2	83.35	84.3
2	0	0	0	68.81	68.62	68.73
2	1	0	0	109.09	103.95	107.85
2	2	0	0	107.1	101.43	102.42
2	3	0	0	112.25	98.73	99.66
2	4	0	0	96.18	95.63	95.95
2	5	0	0	93.63	89.97	92.87
2	6	0	0	91.89	91.22	91.52
2	1	1	0	113.09	110.1	110.4
2	1	2	0	117.01	115.45	116.21
2	1	3	0	104.82	96.02	103.27
2	1	4	0	110.81	109.67	110.4
2	1	5	0	101.17	98.35	100.55
2	1	6	0	113.13	110.68	112.23
2	2	2	0	104.21	101.42	102.82
2	2	3	0	111.86	108.1	109.25
2	2	4	0	99.96	98.43	99.11
2	2	5	0	106.83	102.07	105.26
2	2	6	0	98.12	96.53	97.29
2	3	3	0	108.2	101.27	107.19
2	3	4	0	97.52	96.72	97.15
2	3	5	0	105.16	98.48	103.96
2	3	6	0	95.55	91.24	94.36
2	4	4	0	106.17	103.34	104.16
2	4	5	0	96.8	95.92	96.38
2	4	6	0	102.74	97.95	100.64
2	5	5	0	93.83	92.83	93.35
2	5	6	0	103.95	98.63	99.52
2	6	6	0	92.14	91.08	91.6
2	1	1	1	118.28	116.47	117.77
2	1	1	2	114.4	111.7	113.21
2	1	1	3	112.94	109.71	111.81
2	1	1	4	111.49	105.62	110.51
2	1	1	5	113.13	110.02	111.6
2	1	1	6	110.51	106.26	108.42
2	1	2	2	112.25	108.95	110.94
2	1	2	3	110.61	107.58	109.39
2	1	2	4	111.91	109.23	110.59
2	1	2	5	112.18	101.1	107.01
2	1	2	6	108.34	104.31	106.27
2	1	3	3	109.56	101.87	107.76
2	1	3	4	110.29	106.88	108.99
2	1	3	5	111.32	104.11	106.09
2	1	3	6	106.08	97.23	103.98
2	1	4	4	107.35	103.91	105.66
2	1	4	5	108.2	104.79	106.99
2	1	4	6	105.65	102.2	103.76
2	1	5	5	105.54	96.24	103.42
2	1	5	6	104.34	97.6	102.18
2	1	6	6	107.63	102.05	104.51
2	2	2	2	110.16	107.02	108.86
2	2	2	3	108.26	105.3	106.67
2	2	2	4	106.97	102.02	105.57
2	2	2	5	111.44	105.7	107.34
2	2	2	6	105.79	102.48	104.18
2	2	3	3	107.07	97.49	105.43
2	2	3	4	105.53	102.32	104.4
2	2	3	5	108.01	103.58	105.81
2	2	3	6	104.71	101.02	102.78
2	2	4	4	105	101.93	103.31
2	2	4	5	107.3	98.37	102.28
2	2	4	6	105.67	102.24	104.03
2	2	5	5	102.87	99.74	101.36
2	2	5	6	102.25	97.57	100.13
2	2	6	6	102.9	97.96	99.95
2	3	3	3	107.36	104.91	106.36
2	3	3	4	104.02	101.73	102.88
2	3	3	5	104.26	100.23	102.23
2	3	3	6	102.92	99.35	101.26
2	3	4	4	107.1	102.9	104.34
2	3	4	5	102.75	99.22	100.92
2	3	4	6	105.98	98.54	100.31
2	3	5	5	102.67	98.94	100.62
2	3	5	6	104.01	99.87	101.35
2	3	6	6	100.44	97.38	98.89
2	4	4	4	102.86	99.75	100.94
2	4	4	5	101.5	97	99.62
2	4	4	6	102.57	99.79	101.07
2	4	5	5	99.68	96.1	98.73
2	4	5	6	99.49	97.28	98.12
2	4	6	6	99.09	96.16	97.3
2	5	5	5	101.44	98.85	100.04
2	5	5	6	98.31	92.41	96.79
2	5	6	6	97.58	91.93	96.11
2	6	6	6	96.51	94.71	95.48
3	0	0	0	80.33	77.24	78.03
3	1	0	0	124.02	117.46	117.98
3	2	0	0	111.27	110.95	111.13
3	3	0	0	106.13	104.25	104.44
3	4	0	0	104.81	102.47	104.39
3	5	0	0	111.38	98.19	102.03
3	6	0	0	101.18	99.95	100.31
3	1	1	0	118.83	118.55	118.64
3	1	2	0	125.87	122.91	124.64
3	1	3	0	114.4	105.19	111.36
3	1	4	0	122.76	117.88	120.19
3	1	5	0	110.55	108.1	108.91
3	1	6	0	120.01	118.41	119.61
3	2	2	0	112.34	110.5	111.48
3	2	3	0	119.4	117.23	118.3
3	2	4	0	109.62	106.33	108.18
3	2	5	0	115.78	114.15	115.16
3	2	6	0	106.17	105	105.56
3	3	3	0	118.05	112.63	115.53
3	3	4	0	106.71	103.28	105.47
3	3	5	0	118.37	108	112.1
3	3	6	0	105.99	101.56	103.22
3	4	4	0	114.72	111.91	112.9
3	4	5	0	105.56	103.75	104.64
3	4	6	0	111.32	105.88	109.17
3	5	5	0	102.65	101.48	102.12
3	5	6	0	108.71	106.59	107.49
3	6	6	0	100.45	99.47	100.12
3	1	1	1	140.71	125.61	127.18
3	1	1	2	122.53	121.15	121.89
3	1	1	3	121.13	119.07	120.44
3	1	1	4	120.92	110.9	118.99
3	1	1	5	121.23	119.21	120.2
3	1	1	6	119.09	115.23	117.18
3	1	2	2	120.9	118.37	119.71
3	1	2	3	121.87	113.73	118.2
3	1	2	4	120.39	117.84	119.14
3	1	2	5	117.48	114.19	115.9
3	1	2	6	116.19	106.31	114.51
3	1	3	3	122.09	115.04	116.94
3	1	3	4	119.34	115.97	117.42
3	1	3	5	115.82	112.24	114.5
3	1	3	6	115.03	112.02	113.42
3	1	4	4	116.82	111.45	114.43
3	1	4	5	116.72	114.3	115.54
3	1	4	6	115.88	107.96	112.4
3	1	5	5	118.04	105.83	112.45
3	1	5	6	112.78	109.33	111.56
3	1	6	6	114.38	110.9	112.9
3	2	2	2	118.44	116.67	117.39
3	2	2	3	120.13	108.34	115.15
3	2	2	4	116.19	109.64	114.49
3	2	2	5	116.73	114.25	115.82
3	2	2	6	114.56	110.8	112.66
3	2	3	3	116.7	107.31	113.94
3	2	3	4	115.9	110.81	113.25
3	2	3	5	115.81	112.37	114.01
3	2	3	6	112.99	109.5	111.26
3	2	4	4	114.75	109.84	111.88
3	2	4	5	113.89	107.85	111.21
3	2	4	6	114.99	109.68	112.7
3	2	5	5	113.65	107.92	110.19
3	2	5	6	110.48	103.25	109.21
3	2	6	6	110.02	106.78	108.52
3	3	3	3	116.76	112.34	114.19
3	3	3	4	118.7	110.17	111.86
3	3	3	5	112.35	104.33	110.38
3	3	3	6	111.47	107.23	109.22
3	3	4	4	114.65	109.41	112.63
3	3	4	5	111.47	107.97	109.44
3	3	4	6	110.3	106.77	108.46
3	3	5	5	110.61	104.9	108.58
3	3	5	6	113.62	109.21	110.58
3	3	6	6	109.72	104.94	106.77
3	4	4	4	111.23	102.6	109.32
3	4	4	5	110.83	106.14	108.05
3	4	4	6	113.32	107.6	111.26
3	4	5	5	109.17	103.17	107.65
3	4	5	6	107.78	105.13	106.69
3	4	6	6	107.24	104.64	106.03
3	5	5	5	109.39	107.46	108.51
3	5	5	6	106.94	102.1	105.31
3	5	6	6	106.07	103.49	104.75
3	6	6	6	106.31	102.7	104.27
4	0	0	0	86.02	85.95	85.99
4	1	0	0	126.33	126.01	126.2
4	2	0	0	120.33	119.21	119.89
4	3	0	0	126.96	113.48	116.12
4	4	0	0	123.96	106.75	113.57
4	5	0	0	110.68	109.64	110.13
4	6	0	0	109.04	108.53	108.76
4	1	1	0	131.42	127.31	127.81
4	1	2	0	134.26	123.33	131.43
4	1	3	0	121.15	113.29	120.34
4	1	4	0	131.54	128.92	130.12
4	1	5	0	119.78	112.44	117.61
4	1	6	0	131.6	127.75	129.67
4	2	2	0	120.57	117.78	119.74
4	2	3	0	128	124.46	126.38
4	2	4	0	117.6	115.39	116.38
4	2	5	0	128.48	118.81	123.8
4	2	6	0	115.56	113.57	114.83
4	3	3	0	126.43	122.06	125.09
4	3	4	0	115.76	112.2	114.37
4	3	5	0	126.03	114.89	121.26
4	3	6	0	115.21	108.8	111.54
4	4	4	0	132.2	118.01	121.8
4	4	5	0	115.27	112.3	113.56
4	4	6	0	118.79	114.81	117.08
4	5	5	0	113.38	107.44	109.88
4	5	6	0	121.94	112.51	116.34
4	6	6	0	109.05	107.6	108.63
4	1	1	1	136.91	134.34	135.47
4	1	1	2	131.68	121.85	129.93
4	1	1	3	130.91	126.99	129.23
4	1	1	4	130.16	126.16	128.18
4	1	1	5	130.85	127.08	128.69
4	1	1	6	128.26	123.84	125.74
4	1	2	2	129.68	117.08	127.15
4	1	2	3	129.26	124.99	126.82
4	1	2	4	129.87	126.02	127.76
4	1	2	5	127.38	122.96	124.73
4	1	2	6	125.47	116.11	123.69
4	1	3	3	128.43	117.21	124.86
4	1	3	4	129.02	123.69	126.46
4	1	3	5	136.81	120.47	123.33
4	1	3	6	124.31	121.5	122.52
4	1	4	4	126.12	117.4	121.82
4	1	4	5	127.03	121.54	124.03
4	1	4	6	124.53	118.13	120.63
4	1	5	5	126.67	117.72	120.9
4	1	5	6	122.41	119.26	120.66
4	1	6	6	127.19	121.21	122.26
4	2	2	2	126.48	125.4	125.95
4	2	2	3	125.29	123.76	124.48
4	2	2	4	124.39	121.54	123.34
4	2	2	5	128.05	121.51	125.37
4	2	2	6	122.57	121.23	121.74
4	2	3	3	124.63	122.45	123.52
4	2	3	4	125	119.28	121.84
4	2	3	5	125.33	121.01	122.53
4	2	3	6	122.21	119.03	120.09
4	2	4	4	123.9	115.16	120.25
4	2	4	5	124.45	117.46	121.01
4	2	4	6	123.94	118.1	121.15
4	2	5	5	120.48	116.13	118.89
4	2	5	6	119.7	115.85	117.95
4	2	6	6	130.37	115.22	118.35
4	3	3	3	125.44	122.29	123.78
4	3	3	4	124.25	114.39	119.29
4	3	3	5	121.46	111.92	118.67
4	3	3	6	120.2	117.24	118.76
4	3	4	4	124.65	117.35	121.37
4	3	4	5	124.31	116.05	118.49
4	3	4	6	120.85	110.82	116.76
4	3	5	5	121.21	113.83	117.71
4	3	5	6	121.42	116.84	119.08
4	3	6	6	118.29	114.13	116.3
4	4	4	4	122.14	114.82	118.65
4	4	4	5	120.48	113	115.69
4	4	4	6	120.15	114.87	117.74
4	4	5	5	120.62	111.11	115.76
4	4	5	6	118.64	112.57	115.13
4	4	6	6	118.3	112.19	115.11
4	5	5	5	121.27	114.66	117.34
4	5	5	6	117.76	111.76	113.89
4	5	6	6	114.73	111.94	113.43
4	6	6	6	114.49	110.43	112.25
5	0	0	0	96.89	94.55	94.87
5	1	0	0	134.82	130.5	134
5	2	0	0	128.59	128.44	128.52
5	3	0	0	124.78	118.31	123.95
5	4	0	0	121.8	119.14	121.25
5	5	0	0	132.58	112.14	122.45
5	6	0	0	119.51	117.54	118.43
5	1	1	0	134.87	134.43	134.68
5	1	2	0	142.47	141.54	141.88
5	1	3	0	129.68	121.13	128.82
5	1	4	0	142.77	129.48	138.21
5	1	5	0	128.76	119.91	125.76
5	1	6	0	135.98	132.57	134.36
5	2	2	0	128.83	128.12	128.46
5	2	3	0	149.56	135.18	136.49
5	2	4	0	125.6	124.59	125.01
5	2	5	0	133.43	125.88	130.89
5	2	6	0	125.1	123.06	124.02
5	3	3	0	136.5	131.94	132.98
5	3	4	0	123.88	121.98	123.27
5	3	5	0	132.36	127.94	130.05
5	3	6	0	121.29	119.52	120.47
5	4	4	0	133.64	129.85	132.08
5	4	5	0	121.56	118.06	120.03
5	4	6	0	132.13	122.47	127.23
5	5	5	0	123.64	113.89	118.4
5	5	6	0	128.71	120.09	124.76
5	6	6	0	120.11	112.73	117.06
5	1	1	1	142.71	141.09	141.86
5	1	1	2	150.32	138.56	140.28
5	1	1	3	139.02	136.61	137.74
5	1	1	4	138.47	135.18	137.02
5	1	1	5	139.56	131.15	134.99
5	1	1	6	144.4	132.2	135.26
5	1	2	2	138.05	135.98	137.01
5	1	2	3	136.9	134.63	135.77
5	1	2	4	136.32	132.8	134.52
5	1	2	5	138.78	128.06	133.82
5	1	2	6	134.76	131.05	132.73
5	1	3	3	135.71	132.89	134.23
5	1	3	4	138.3	131.61	133.5
5	1	3	5	136.34	126.48	131.74
5	1	3	6	133.4	122.13	130.28
5	1	4	4	134.27	128.73	131.71
5	1	4	5	138.51	127.47	131.08
5	1	4	6	132.75	127.85	129.94
5	1	5	5	137.93	124.66	129.59
5	1	5	6	133.16	124.22	129.25
5	1	6	6	133.2	123.72	128.51
5	2	2	2	135.73	133.77	134.85
5	2	2	3	134.3	132.45	133.15
5	2	2	4	135.4	129.76	132.66
5	2	2	5	132.5	128.51	131.06
5	2	2	6	131.43	127.7	129.57
5	2	3	3	132.97	130.68	131.7
5	2	3	4	145.52	126.82	131.61
5	2	3	5	132.21	127.65	129.59
5	2	3	6	130.51	126.19	128.95
5	2	4	4	132.88	126.02	128.94
5	2	4	5	131.57	126.11	128.59
5	2	4	6	129.76	124.09	127.01
5	2	5	5	132.84	119.78	127.33
5	2	5	6	130.11	122.69	127.55
5	2	6	6	128.15	122.65	125.48
5	3	3	3	131.17	129.66	130.23
5	3	3	4	132.23	127.71	129.31
5	3	3	5	130.7	126.15	128.2
5	3	3	6	129.73	124.76	127.4
5	3	4	4	131.17	125.22	127.74
5	3	4	5	129.48	122.43	126.6
5	3	4	6	128.37	122.2	125.14
5	3	5	5	130.53	119.84	126.79
5	3	5	6	128.21	123.51	126.3
5	3	6	6	128.72	119.92	123.56
5	4	4	4	128.97	123.09	126.63
5	4	4	5	128.62	121.56	125.53
5	4	4	6	128.49	121.03	124.36
5	4	5	5	133.16	119.57	124.34
5	4	5	6	127.62	117.34	123.06
5	4	6	6	126.52	121.06	123.2
5	5	5	5	128.09	117.93	122.99
5	5	5	6	127.61	117.79	123.1
5	5	6	6	126.33	115.17	121.3
5	6	6	6	125.68	116.61	121.76
6	0	0	0	103.17	103.09	103.13
6	1	0	0	143.65	143.38	143.51
6	2	0	0	138.88	136.04	136.89
6	3	0	0	133.81	126.86	132.97
6	4	0	0	130.46	128.16	129.95
6	5	0	0	128.48	123.47	126.84
6	6	0	0	137.72	121.26	129.04
6	1	1	0	143.64	143.41	143.51
6	1	2	0	156.26	148.81	151.17
6	1	3	0	138.72	126.35	136.74
6	1	4	0	147.63	145.77	146.72
6	1	5	0	138.04	133.4	135.38
6	1	6	0	155.25	134.35	143.73
6	2	2	0	137.74	135.82	136.95
6	2	3	0	144.24	142.81	143.61
6	2	4	0	134.08	132.23	133.2
6	2	5	0	142.46	137.48	141.03
6	2	6	0	133.66	129.68	131.52
6	3	3	0	143.29	140.74	141.54
6	3	4	0	133.98	127.74	131.97
6	3	5	0	143.57	129.28	138.35
6	3	6	0	130.5	127.58	128.98
6	4	4	0	140.78	139.18	140.07
6	4	5	0	132.74	128.11	128.95
6	4	6	0	138.5	131.44	135.17
6	5	5	0	130.05	123.3	127.14
6	5	6	0	138.07	123.82	132.6
6	6	6	0	132.12	119.76	125.36
6	1	1	1	150.48	149.99	150.34
6	1	1	2	148.43	147.6	148.1
6	1	1	3	147.58	136.24	145.52
6	1	1	4	146.39	144.88	145.66
6	1	1	5	148.73	141.52	144.51
6	1	1	6	145.53	140.84	143.12
6	1	2	2	146.67	144.07	145.65
6	1	2	3	145.84	139.68	144
6	1	2	4	144.8	142.22	143.54
6	1	2	5	143.85	139.57	141.92
6	1	2	6	144.86	138.69	140.93
6	1	3	3	144.22	142.07	143.25
6	1	3	4	143.64	139.82	141.95
6	1	3	5	141.81	138.99	140.68
6	1	3	6	142.25	137.85	139.77
6	1	4	4	144.13	138.16	140.68
6	1	4	5	140.61	137.36	139.42
6	1	4	6	141.59	135.67	138.78
6	1	5	5	142.25	134.24	138.52
6	1	5	6	142.44	131.81	138.2
6	1	6	6	143.39	132.88	136.9
6	2	2	2	146.66	141.3	143.56
6	2	2	3	142.57	140.86	141.76
6	2	2	4	143.17	139.39	140.73
6	2	2	5	141.84	137.11	139.17
6	2	2	6	142.72	135.78	139.07
6	2	3	3	141.84	135.5	139.85
6	2	3	4	140.53	132.8	139
6	2	3	5	139.43	136.85	138.32
6	2	3	6	142.22	131.78	136.81
6	2	4	4	139.66	136.68	138.43
6	2	4	5	138.7	133.05	136.9
6	2	4	6	142.38	131.17	135.22
6	2	5	5	139.14	132.63	136.35
6	2	5	6	139.03	131.83	134.92
6	2	6	6	140.11	131.84	135.24
6	3	3	3	142.52	137.87	139.32
6	3	3	4	139	136.56	137.53
6	3	3	5	137.44	134.86	136.43
6	3	3	6	140.83	132.27	135.4
6	3	4	4	137.29	135.23	136.67
6	3	4	5	137.72	130.42	135.38
6	3	4	6	136.84	132.06	134.39
6	3	5	5	145.13	130.85	135.27
6	3	5	6	135.67	129.98	133.5
6	3	6	6	140.97	127.65	132.82
6	4	4	4	136.94	128.36	134.21
6	4	4	5	137.44	129.5	133.69
6	4	4	6	136.89	130.72	133.07
6	4	5	5	138.39	130.04	134.1
6	4	5	6	137.42	127.98	131.83
6	4	6	6	137.8	127.09	131.83
6	5	5	5	134.72	127.78	131.43
6	5	5	6	136.5	127.62	130.95
6	5	6	6	136.09	125.39	130.47
6	6	6	6	134.31	121.29	127.76
*/