ccom.C

Go to the documentation of this file.

// ccom.C

#include <stdio.h>
#include <string.h>
#include <iostream.h>

#include "TinkerKnobs.H"
#include "lego.H"
#include "legoAn.H"
#include "legoSO.H"
#include "legoRForm.H"
//#include "legoSched.H"
#include "list_scheduler.H"
#include "schedule.H"
#include "modify.H"
#include "scheduling_utilities.H"
#include "hyperform.H"

#define       YES     1
#define       NO      0

time_t start, finish;
clock_t start_clock, finish_clock;
clock_t start_rform, finish_rform;
clock_t start_sched, finish_sched;
clock_t start_dag, finish_dag;
clock_t start_live, finish_live;
clock_t start_rdef, finish_rdef;
double total, total_clock, clocks_per_sec = CLOCKS_PER_SEC;
double total_rform=0, total_sched=0, total_dag=0, total_live=0, total_rdef=0; 
extern chains* Chains;
int dom_parallel_ops=0, copy_ops_added=0, speculated_ops=0;  
int liveness_renamed_ops=0, falsedep_renamed_ops=0, combine_renamed_ops=0;
int liveness_calls=0, rdef_calls=0; 
int downward_motion_ops=0, unspeculated_ops=0, unspeculated_pbr_ops=0, dead_ops=0;
double downward_dynamic_op_reduction=0, combine_dynamic_op_reduction=0;
double speculative_dynamic_op_increase=0, multiway_dynamic_op_reduction=0;
double copy_dynamic_op_increase=0;
int total_branch_multiops=0, total_branch_ops=0, blocks_removed=0; 

void
ShowSyntax (void)
{
  printf ("\n\nLEGO ccom Syntax\n\n");
  printf ("ccom [-h|-help] [-v|-verbose] [-K\"knob-name knob-type "
          "knob-value\"]*\n"
          "  [-kf knob-file] [-n|-nooutput|-o output-file] file\n");
  exit(1);
} // end ShowSyntax

int
main (int argc, char *argv[])
{
        legoModule *M;
        knobs *K;
        char *knobfile = NULL, *inputfile = NULL, *outputfile = NULL;
        int verbose = 0, nooutput = 0;
        tree_stats *tree_st = NULL;

        tree_st = new tree_stats ("will_not_dump");
   /* READ ARGUMENTS */ 
        for (int i = 1; i < argc; i++)
        {
                char *arg = argv[i];

                if (strcmp (arg, "-help") == 0 ||
                  strcmp (arg, "-h") == 0)
                ShowSyntax();

                if (strcmp (arg, "-v") == 0 ||
                  strcmp (arg, "-verbose") == 0)
                {
                  verbose = 1;
                  continue;
                } // end if

                if (strcmp (arg, "-n") == 0 ||
                  strcmp (arg, "-nooutput") == 0)
                {
                  nooutput = 1;
                  continue;
                } // end if

                if (strcmp (arg, "-kf") == 0)
                {
                  knobfile = argv[++i];
                  continue;
                } // end if

                if (strcmp (arg, "-o") == 0)
                {
                  outputfile = argv[++i];
                  continue;
                } // end if

                if (arg[0] == '-' && arg[1] == 'K')
                continue;

                inputfile = arg;
        } // end for

        if (inputfile == NULL)
        {
                printf ("ccom| No input file specified.");
                ShowSyntax();
        } // end if

  if (verbose)
         printf ("ccom| Reading in knobs.\n");
  K = new knobs (knobfile);
  K->Parse (argc, argv);

  if (verbose)
         printf ("ccom| Loading input file %s.\n", inputfile);
  M = new legoModule;
  LegoRead_IA64 (inputfile, M);
  IA64Write(M,"ReadOutput.s");

  //=====================================================================
  // 1. REGION FORMATION
  //=====================================================================

  char *regiontype;
  legoProc *P;
  legoTreegion *T;
  int maxid, ooc = M->GetOpCount();

  K->SetDefaultPanel ("ccom");

  K->Read ("region", regiontype);
  if (strcmp (regiontype, "basic-block") != 0 &&
                strcmp (regiontype, "treegion") != 0 &&
                strcmp (regiontype, "FICT") != 0 &&
                strcmp (regiontype, "lineartrees") != 0 &&
                strcmp (regiontype, "superblock") != 0)
         LegoFatal ("ccom", "Unknown region type \"%s\".", regiontype);

  start = time(NULL);
  start_clock = clock();
  //cerr.setf(ios::fixed,ios::floatfield); 
  //cerr.precision(4); 
  start_rform = clock();

         if (verbose)
         printf ("ccom| Forming %ss \n", regiontype);
        if (strcmp (regiontype, "basic-block") == 0) 
        {
                for (unsigned i = 0; i < M->GetCount(); i++)
                {
                        P = (legoProc *) M->GetItem (i);
                        // UnBindSB elcor superblocks (represented as hbs) for true BBs
                        UnBindSB(P);
                        if (verbose)
                        {
                           putchar ('.');
                           fflush (stdout);
                        } // end if
                } // end for    
                if (verbose) putchar ('\n');
        }
        else
        if (strcmp (regiontype, "treegion") == 0)
        {
        //      for (unsigned i = 1; i <= 1; i++)
                        for (unsigned i = 0; i < M->GetCount(); i++)
                {
                  P = (legoProc *) M->GetItem (i);
                  NextPredRegNum = 0;
                  maxid = (P->FindMaxRegionId())->GetRegionId();
                  treeform (P, maxid, K, tree_st);
                  if (verbose)
                         {
                                putchar ('.');
                                fflush (stdout);
                         } // end if
                } // end for
                        if (verbose) putchar ('\n');
        } 
        else if (strcmp (regiontype, "FICT") == 0)
        {
                                if (verbose) {
                        putchar ('\n');
                        printf ("ccom| Start by forming Treegion \n");
                                }
                                for (unsigned i = 0; i < M->GetCount(); i++)
                        {
                          P = (legoProc *) M->GetItem (i);
                          NextPredRegNum = 0;
                          maxid = (P->FindMaxRegionId())->GetRegionId();
                          treeform (P, maxid, K, tree_st);
                          if (verbose)
                                 {
                                        putchar ('.');
                                        fflush (stdout);
                                 } // end if
                        } // end for
                                if (verbose) {
                        putchar ('\n');
                        printf ("ccom| Fully If-Converting Treegion \n");
                                }
                                for (unsigned i = 0; i < M->GetCount(); i++) {
                        P = (legoProc *) M->GetItem (i);
                        Chains = ReachingDefinitions (P, K);
                        NextPredRegNum = 0;
                        for (unsigned j = 0; j < P->GetCount(); j++) {
                          T = (legoTreegion *) P->GetItem (j); 
                          FullyIfConvertTreeBranch (T, K);
                        }
                        if (verbose)
                          {
                                 putchar ('.');
                                 fflush (stdout);
                          } // end if
                                }
                                if (verbose) putchar ('\n');
        } 
        else if (strcmp (regiontype, "lineartrees") == 0)
        {
                        if (verbose) {
                putchar ('\n');
                printf ("ccom| Start by forming Treegion \n");
                        }
                        for (unsigned i = 0; i < M->GetCount(); i++)
                {
                  P = (legoProc *) M->GetItem (i);
                  NextPredRegNum = 0;
                  maxid = (P->FindMaxRegionId())->GetRegionId();
                  treeform (P, maxid, K, tree_st);
                  if (verbose)
                         {
                                putchar ('.');
                                fflush (stdout);
                         } // end if
                } // end for
                        if (verbose) {
                putchar ('\n');
                printf ("ccom| Decomposing Treegion into Linear Trees \n");
                        }
                        for (unsigned i = 0; i < M->GetCount(); i++) {
                P = (legoProc *) M->GetItem (i);
                Chains = ReachingDefinitions (P, K);
                NextPredRegNum = 0;
                for (unsigned j = 0; j < P->GetCount(); j++) {
                  T = (legoTreegion *) P->GetItem (j); 
                  lineartreesfromtreegions (T);
                }
                if (verbose)
                  {
                         putchar ('.');
                         fflush (stdout);
                  } // end if
                        }
                        if (verbose) putchar ('\n');
        } 
        else if (strcmp (regiontype, "superblock") == 0)
        {
                for (unsigned i = 0; i < M->GetCount(); i++)
                {
                  P = (legoProc *) M->GetItem (i);
                  superform (P, K);
                  if (verbose)
                         {
                                putchar ('.');
                                fflush (stdout);
                         } // end if
                } // end for
                        if (verbose) putchar ('\n');
        } // end else

  finish_rform = clock();
  IA64Write(M,"RegionOutput.s");

  //=====================================================================
  // 
  // 2. SCHEDULING
  //
  //=====================================================================

  unsigned i;
  char *debug_stats;
  char do_schedule, two_pass, fully_predicate, if_convert_and_predicate, fully_if_convert, append_debug_stats;
  //char op_schedule;
  ofstream debugstatsf;
  machine *mach;
  schedule_stats *ss;
  static_stats *st_st;

  K->Read ("ccom:do-schedule", do_schedule);
  //K->Read ("ccom:op-schedule", op_schedule);
  K->Read ("ccom:two-pass", two_pass);
  K->Read ("ccom:fully-predicate", fully_predicate);
  K->Read ("ccom:if-convert-and-predicate", if_convert_and_predicate);
  K->Read ("ccom:fully-if-convert", fully_if_convert);

  start_sched = clock();
  
  ss = new schedule_stats;
  ss->original_op_count = ss->final_op_count = 0;
  ss->instrs_scheduled = ss->schedule_length = 0;
  ss->instr_count = ss->cycle_count = 0;
  
  st_st = new static_stats;

        if (do_schedule)
        {
                if (verbose)
                printf ("ccom| Scheduling \n\n");
                mach = new machine (K);                 // The constructor of machine class
                                                                                                // also loads the lmdes file. 

                K->Read ("ccom:debug-stats", debug_stats);
                if (debug_stats != NULL)
                {
                  if (verbose)
                         printf ("ccom| Writing debug stats to %s.\n", debug_stats);
                  K->Read ("ccom:append-debug-stats", append_debug_stats);
                  if (append_debug_stats)
                         debugstatsf.open (debug_stats, ios::out);
                  else
                         debugstatsf.open (debug_stats, ios::app);
                } // end if

                for (i = 0; i < M->GetCount(); i++)
                {
                  P = (legoProc *) M->GetItem (i);
                  ResetSchedTimes( P );
                  start_dag = clock();
                  BuildDagsForProc (P, mach, K);
                  finish_dag = clock();
                  total_dag = total_dag + ((finish_dag - start_dag) / clocks_per_sec);
                  SetNodeHeightsAndDepthsForProc (P);
                  printf("7i=%d\n",i); 
                  SetValuesForProc (P, K);
                  mach->resetMachine();
                  if (strcmp (regiontype, "FICT") == 0) 
                  {
                         // Do not allow speculation during scheduling if regiontype is FICT
                         ScheduleProc (P, ss, 0, &debugstatsf, K, NO, YES);
                  } else 
                                 if (two_pass) 
                         ScheduleProc (P, ss, 0, &debugstatsf, K, NO, NO);
                  else 
                         ScheduleProc (P, ss, 0, &debugstatsf, K, YES, NO);
                  DeleteDagsInProc( P );

                  if (verbose)
                  {
                                putchar ('.');
                                fflush (stdout);
                  } // end if
                } // end for

                if (two_pass) 
                {
                        if (fully_predicate) 
                        {
                          if (verbose) {
                                 putchar ('\n');
                                 printf ("ccom| Fully Predicating Treegion \n");
                          }
                        //        for (unsigned i = 1; i <= 1; i++)
                          for (unsigned i = 0; i < M->GetCount(); i++) 
                                 {
                                        P = (legoProc *) M->GetItem (i);
                                        Chains = ReachingDefinitions (P, K);
                                        NextPredRegNum = 0;
                                        for (unsigned j = 0; j < P->GetCount(); j++) {
                                T = (legoTreegion *) P->GetItem (j); 
                                FullyPredicateTreeBranch (T);
                                        }
                                        if (verbose)
                                {
                                  putchar ('.');
                                  fflush (stdout);
                                } // end if
                                 }
                          if (verbose) putchar ('\n');
                        }
                        else if (if_convert_and_predicate) 
                        {
                                if (verbose) 
                                {
                                 putchar ('\n');
                                 printf ("ccom| If-Converting and Predicating Treegion \n");
                                }
                                for (unsigned i = 0; i < M->GetCount(); i++) 
                                {
                                        P = (legoProc *) M->GetItem (i);
                                        Chains = ReachingDefinitions (P, K);
                                        NextPredRegNum = 0;
                                        for (unsigned j = 0; j < P->GetCount(); j++) 
                                        {
                                                T = (legoTreegion *) P->GetItem (j); 
                                                IfConvertAndPredicateTreeBranch (T, K);
                                        }
                                        if (verbose)
                                        {
                                                putchar ('.');
                                                fflush (stdout);
                                        } // end if
                                }
                          if (verbose) putchar ('\n');
                        }
                else if (fully_if_convert) {
                  if (verbose) {
                         putchar ('\n');
                         printf ("ccom| Fully If-Converting Treegion \n");
                  }
                  for (unsigned i = 0; i < M->GetCount(); i++) {
                         P = (legoProc *) M->GetItem (i);
                         Chains = ReachingDefinitions (P, K);
                         NextPredRegNum = 0;
                         for (unsigned j = 0; j < P->GetCount(); j++) {
                                T = (legoTreegion *) P->GetItem (j); 
                                FullyIfConvertTreeBranch (T, K);
                         }
                         if (verbose)
                                {
                        putchar ('.');
                        fflush (stdout);
                                } // end if
                  }
                  if (verbose) putchar ('\n');
                }
                if (verbose)
                  printf ("ccom| 2nd Pass Scheduling \n");
                //      for (unsigned i = 1; i <= 1; i++)
                for (i = 0; i < M->GetCount(); i++)
                  {
                         P = (legoProc *) M->GetItem (i);
                         ResetSchedTimes( P );
                         start_dag = clock();
                         BuildDagsForProc (P, mach, K);
                         finish_dag = clock();
                         total_dag = total_dag + ((finish_dag - start_dag) / clocks_per_sec);
                         //cerr << "total_dag ticks = " << total_dag << " so far\n";
                         SetNodeHeightsAndDepthsForProc (P);
                         SetValuesForProc (P, K);
                         mach->resetMachine();
                         ScheduleProc (P, ss, 0, &debugstatsf, K, YES, YES);
                         DeleteDagsInProc( P );
                         if (verbose)
                                {
                        putchar ('.');
                        fflush (stdout);
                                } // end if
                  } // end for  
                        }

                // Have to backpatch the original_op_count, since the scheduler
                // will have never seen the old count.
        // want tail-duplication expansion even if no sched, now doing below uncond. 
        //      ss->original_op_count = ooc;
                

                // Add the new static estimation
                st_st = StaticEstimate (M);

                if (debug_stats != NULL) debugstatsf.close();
                delete mach;

                if (verbose) putchar ('\n');
        } // end if

  finish_sched = clock();
  finish = time(NULL);
  total = difftime(finish, start);
  finish_clock = clock();
  total_clock = ((finish_clock - start_clock) / clocks_per_sec);
  //=====================================================================

  // REPORTING

  char *stats;
  char append_stats;
  FILE *sf;

// want tail-duplication expansion even if no sched
  ss->original_op_count = ooc;
// delay of removing dom // ops using dp_remove (so rdefs are maintained) 
// fucks up final count, so re-do now 
  ss->final_op_count = M->GetOpCount();

//  if (do_schedule)
//    {
                K->Read ("ccom:stats", stats);
                if (stats != NULL)
        {
          if (verbose)
                 printf ("ccom| Writing statistics to %s.\n", stats);
          K->Read ("ccom:append-stats", append_stats);
          if (append_stats)
                 sf = fopen (stats, "a");
          else
                 sf = fopen (stats, "w");
          if (sf == NULL)
                 LegoFatal ("ccom", "Couldn't open statistics file %s.", stats);
          fprintf (sf, "Statistics for file %s:\n", inputfile);
          fprintf (sf, "\tOriginal op count: %d\n", ss->original_op_count);
          fprintf (sf, "\tFinal op count: %d\n", ss->final_op_count);
          fprintf (sf, "\tNumber of instructions scheduled: %d\n",
                        ss->instrs_scheduled);
          fprintf (sf, "\tTotal schedule length: %d\n", ss->schedule_length);
          fprintf (sf, "\tTotal instruction count: %lf\n", ss->instr_count);
          fprintf (sf, "\tTotal cycle count: %lf\n", ss->cycle_count);
          fprintf (sf, "\tNEW -- number of Dynamic Ops: %lf\n", st_st->numDynamicOps);
          fprintf (sf, "\tNEW -- number of Cycles: %lf\n", st_st->numCycles);
          total_rform = ((finish_rform - start_rform) / clocks_per_sec);
          total_sched = ((finish_sched - start_sched) / clocks_per_sec);
          fprintf (sf, "\tMain elapsed time is %lf seconds\n", total);
          fprintf (sf, "\tMain elapsed time is %lf ticks\n", total_clock); 
          fprintf (sf, "\tTotal of %d RDefs() calls elapsed time is %lf ticks\n", rdef_calls, total_rdef); 
          fprintf (sf, "\tTotal of %d LiveVar() calls elapsed time is %lf ticks\n", liveness_calls, total_live);
          fprintf (sf, "\tTotal BuildDagsForProc() calls elapsed time is %lf ticks\n", total_dag); 
          fprintf (sf, "\tNumber of trees formed is %d \n", tree_st->tree_count);         
          fprintf (sf, "\tOriginal number of basic blocks is %d \n", tree_st->block_count);       
          fprintf (sf, "\tBasic blocks removed is %d \n", blocks_removed);        
          fprintf (sf, "\tStatic path blocks is %d \n", tree_st->path_blocks); 
          fprintf (sf, "\tStatic path count is %d \n", tree_st->path_count); 
          fprintf (sf, "\tDynamic path blocks is %lf \n", tree_st->dynamic_path_blocks); 
          fprintf (sf, "\tDynamic path count is %lf \n", tree_st->dynamic_path_count); 
          fprintf (sf, "\tTotal RForm elapsed time is %lf ticks\n", total_rform);
          fprintf (sf, "\tTotal Sched elapsed time is %lf ticks\n", total_sched);
          fprintf (sf, "\tNumber of combined ops removed is %d \n", dom_parallel_ops);
          fprintf (sf, "\tDynamic op reduction due to combining is %lf \n", combine_dynamic_op_reduction);
          fprintf (sf, "\tNumber of speculated ops is %d \n", speculated_ops);
          fprintf (sf, "\tDynamic op increase due to speculation is %lf \n", speculative_dynamic_op_increase);
          fprintf (sf, "\tNumber of renamed ops (liveness) is %d \n", liveness_renamed_ops);
          fprintf (sf, "\tNumber of renamed ops (falsedep) is %d \n", falsedep_renamed_ops);
          fprintf (sf, "\tNumber of renamed ops (combine) is %d \n", combine_renamed_ops);
          fprintf (sf, "\tNumber of copy ops added is %d \n", copy_ops_added);
          fprintf (sf, "\tDynamic op increase due to copy ops is %lf \n", copy_dynamic_op_increase);
          fprintf (sf, "\tNumber of downward motion ops is %d \n", downward_motion_ops);
          fprintf (sf, "\tNumber of unspeculated ops is %d \n", unspeculated_ops);
          fprintf (sf, "\tNumber of unspeculated pbr ops is %d \n", unspeculated_pbr_ops);
          fprintf (sf, "\tDynamic op reduction due to unspeculation is %lf \n", downward_dynamic_op_reduction);
          fprintf (sf, "\tNumber of dead ops is %d \n", dead_ops);
          fprintf (sf, "\tNumber of branch multiops is %d \n", total_branch_multiops);
          fprintf (sf, "\tNumber of branch ops is %d \n", total_branch_ops);
          fprintf (sf, "\tDynamic op reduction due to multiway is %lf \n\n", multiway_dynamic_op_reduction);
          fclose (sf);
        } // end if
//    } // end if

  //=====================================================================

  if (verbose && !nooutput)
         printf ("ccom| Writing output to %s.\n", (outputfile != NULL ?
                                                        outputfile : "stdout"));
  if (!nooutput)
         {
                if (outputfile != NULL)
        LegoWrite (M, outputfile);
                else
        LegoWrite (M);
         } // end if

  
  return 0;
} // end main

---