URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [or1ksim/] [cuc/] [cuc.c] - Blame information for rev 1775

Go to most recent revision | Details | Compare with Previous | View Log


/* cuc.c -- OpenRISC Custom Unit Compiler
 
   Copyright (C) 2002 Marko Mlinar, markom@opencores.org
   Copyright (C) 2008 Embecosm Limited
 
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of OpenRISC 1000 Architectural Simulator.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 3 of the License, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   more details.
 
   You should have received a copy of the GNU General Public License along
   with this program.  If not, see <http://www.gnu.org/licenses/>. */
 
/* This program is commented throughout in a fashion suitable for processing
   with Doxygen. */
 
/* Main file, including code optimization and command prompt */
 
 
/* Autoconf and/or portability configuration */
#include "config.h"
#include "port.h"
 
/* System includes */
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
 
/* Package includes */
#include "cuc.h"
#include "sim-config.h"
#include "profiler.h"
#include "insn.h"
#include "opcode/or32.h"
#include "parse.h"
#include "verilog.h"
#include "debug.h"
 
FILE *flog;
int cuc_debug = 0;
 
/* Last used registers by software convention */
/* Note that r11 is caller saved register, and we can destroy it.
   Due to CUC architecture we must always return something, even garbage (so that
   caller knows, we are finished, when we send acknowledge).
   In case r11 was not used (trivial register assignment) we will remove it later,
   but if we assigned a value to it, it must not be removed, so caller_saved[11] = 0 */
const int caller_saved[MAX_REGS] = {
  0, 0, 0, 1, 1, 1, 1, 1,
  1, 1, 0, 0, 0, 1, 0, 1,
  0, 1, 0, 1, 0, 1, 0, 1,
  0, 1, 0, 1, 0, 1, 0, 1,
  1, 1
};
 
/* Does all known instruction optimizations */
void
cuc_optimize (cuc_func * func)
{
  int modified = 0;
  int first = 1;
  log ("Optimizing.\n");
  do
    {
      modified = 0;
      clean_deps (func);
      if (cuc_debug >= 6)
        print_cuc_bb (func, "AFTER_CLEAN_DEPS");
      if (optimize_cmovs (func))
        {
          if (cuc_debug >= 6)
            print_cuc_bb (func, "AFTER_OPT_CMOVS");
          modified = 1;
        }
      if (cuc_debug)
        cuc_check (func);
      if (optimize_tree (func))
        {
          if (cuc_debug >= 6)
            print_cuc_bb (func, "AFTER_OPT_TREE1");
          modified = 1;
        }
      if (remove_nops (func))
        {
          if (cuc_debug >= 6)
            print_cuc_bb (func, "NO_NOPS");
          modified = 1;
        }
      if (cuc_debug)
        cuc_check (func);
      if (remove_dead (func))
        {
          if (cuc_debug >= 5)
            print_cuc_bb (func, "AFTER_DEAD");
          modified = 1;
        }
      if (cuc_debug)
        cuc_check (func);
      if (cse (func))
        {
          log ("Common subexpression elimination.\n");
          if (cuc_debug >= 3)
            print_cuc_bb (func, "AFTER_CSE");
          modified = 1;
        }
      if (first)
        {
          insert_conditional_facts (func);
          if (cuc_debug >= 3)
            print_cuc_bb (func, "AFTER_COND_FACT");
          if (cuc_debug)
            cuc_check (func);
          first = 0;
        }
      if (optimize_bb (func))
        {
          if (cuc_debug >= 5)
            print_cuc_bb (func, "AFTER_OPT_BB");
          modified = 1;
        }
      if (cuc_debug)
        cuc_check (func);
      if (remove_nops (func))
        {
          if (cuc_debug >= 6)
            print_cuc_bb (func, "NO_NOPS");
          modified = 1;
        }
      if (remove_dead_bb (func))
        {
          if (cuc_debug >= 5)
            print_cuc_bb (func, "AFTER_DEAD_BB");
          modified = 1;
        }
      if (remove_trivial_regs (func))
        {
          if (cuc_debug >= 2)
            print_cuc_bb (func, "AFTER_TRIVIAL");
          modified = 1;
        }
      if (remove_nops (func))
        {
          if (cuc_debug >= 6)
            print_cuc_bb (func, "NO_NOPS");
          modified = 1;
        }
      add_memory_dep (func, func->memory_order);
      if (cuc_debug >= 7)
        print_cuc_bb (func, "AFTER_MEMORY_DEP");
      add_data_dep (func);
      if (cuc_debug >= 8)
        print_cuc_bb (func, "AFTER_DATA_DEP");
      if (schedule_memory (func, func->memory_order))
        {
          if (cuc_debug >= 7)
            print_cuc_bb (func, "AFTER_SCHEDULE_MEM");
          modified = 1;
        }
    }
  while (modified);
  set_io (func);
#if 0
  detect_max_values (func);
  if (cuc_debug >= 5)
    print_cuc_bb (func, "AFTER_MAX_VALUES");
#endif
}
 
/* Pre/unrolls basic block and optimizes it */
cuc_timings *
preunroll_bb (char *bb_filename, cuc_func * f, cuc_timings * timings, int b,
              int i, int j)
{
  cuc_func *func;
  cucdebug (2, "BB%i unroll %i times preroll %i times\n", b, j, i);
  log ("BB%i unroll %i times preroll %i times\n", b, j, i);
  func = preunroll_loop (f, b, i, j, bb_filename);
  if (cuc_debug >= 2)
    print_cuc_bb (func, "AFTER_PREUNROLL");
  cuc_optimize (func);
  analyse_timings (func, timings);
 
  cucdebug (2, "new_time = %i, old_time = %i, size = %f\n",
            timings->new_time, func->orig_time, timings->size);
  log ("new time = %icyc, old_time = %icyc, size = %.0f gates\n",
       timings->new_time, func->orig_time, timings->size);
  //output_verilog (func, argv[1]);
  free_func (func);
  timings->b = b;
  timings->unroll = j;
  timings->preroll = i;
  timings->nshared = 0;
  return timings;
}
 
 
/* Simple comparison function */
int
tim_comp (cuc_timings * a, cuc_timings * b)
{
  if (a->new_time < b->new_time)
    return -1;
  else if (a->new_time > b->new_time)
    return 1;
  else
    return 0;
}
 
/* Analyses function; done when cuc command is entered in (sim) prompt */
cuc_func *
analyse_function (char *module_name, long orig_time,
                  unsigned long start_addr, unsigned long end_addr,
                  int memory_order, int num_runs)
{
  cuc_timings timings;
  cuc_func *func = (cuc_func *) malloc (sizeof (cuc_func));
  cuc_func *saved;
  int b, i, j;
  char tmp1[256];
  char tmp2[256];
 
  func->orig_time = orig_time;
  func->start_addr = start_addr;
  func->end_addr = end_addr;
  func->memory_order = memory_order;
  func->nfdeps = 0;
  func->fdeps = NULL;
  func->num_runs = num_runs;
 
  sprintf (tmp1, "%s.bin", module_name);
  cucdebug (2, "Loading %s.bin\n", module_name);
  if (cuc_load (tmp1))
    {
      free (func);
      return NULL;
    }
 
  log ("Detecting basic blocks\n");
  detect_bb (func);
  if (cuc_debug >= 2)
    print_cuc_insns ("WITH_BB_LIMITS", 0);
 
  //sprintf (tmp1, "%s.bin.mp", module_name);
  sprintf (tmp2, "%s.bin.bb", module_name);
  generate_bb_seq (func, config.sim.mprof_fn, tmp2);
  log ("Assuming %i clk cycle load (%i cyc burst)\n", runtime.cuc.mdelay[0],
       runtime.cuc.mdelay[2]);
  log ("Assuming %i clk cycle store (%i cyc burst)\n", runtime.cuc.mdelay[1],
       runtime.cuc.mdelay[3]);
 
  build_bb (func);
  if (cuc_debug >= 5)
    print_cuc_bb (func, "AFTER_BUILD_BB");
  reg_dep (func);
 
  log ("Detecting dependencies\n");
  if (cuc_debug >= 2)
    print_cuc_bb (func, "AFTER_REG_DEP");
  cuc_optimize (func);
 
#if 0
  csm (func);
#endif
  assert (saved = dup_func (func));
 
  timings.preroll = timings.unroll = 1;
  timings.nshared = 0;
 
  add_latches (func);
  if (cuc_debug >= 1)
    print_cuc_bb (func, "AFTER_LATCHES");
  analyse_timings (func, &timings);
 
  free_func (func);
  log ("Base option: pre%i,un%i,sha%i: %icyc %.1f\n",
       timings.preroll, timings.unroll, timings.nshared, timings.new_time,
       timings.size);
  saved->timings = timings;
 
#if 1
  /* detect and unroll simple loops */
  for (b = 0; b < saved->num_bb; b++)
    {
      cuc_timings t[MAX_UNROLL * MAX_PREROLL];
      cuc_timings *ut;
      cuc_timings *cut = &t[0];
      int nt = 1;
      double csize;
      saved->bb[b].selected_tim = -1;
 
      /* Is it a loop? */
      if (saved->bb[b].next[0] != b && saved->bb[b].next[1] != b)
        continue;
      log ("Found loop at BB%x.  Trying to unroll.\n", b);
      t[0] = timings;
      t[0].b = b;
      t[0].preroll = 1;
      t[0].unroll = 1;
      t[0].nshared = 0;
 
      sprintf (tmp1, "%s.bin.bb", module_name);
      i = 1;
      do
        {
          cuc_timings *pt;
          cuc_timings *cpt = cut;
          j = 1;
 
          do
            {
              pt = cpt;
              cpt = preunroll_bb (tmp1, saved, &t[nt++], b, ++j, i);
            }
          while (j <= MAX_PREROLL && pt->new_time > cpt->new_time);
          i++;
          ut = cut;
          cut = preunroll_bb (tmp1, saved, &t[nt++], b, 1, i);
        }
      while (i <= MAX_UNROLL && ut->new_time > cut->new_time);
 
      /* Sort the timings */
#if 0
      if (cuc_debug >= 3)
        for (i = 0; i < nt; i++)
          PRINTF ("%i:%i,%i: %icyc\n",
                  t[i].b, t[i].preroll, t[i].unroll, t[i].new_time);
#endif
 
#if HAVE___COMPAR_FN_T
      qsort (t, nt, sizeof (cuc_timings),
             (__compar_fn_t) tim_comp);
#else
      qsort (t, nt, sizeof (cuc_timings),
             (int (*) (const void *, const void *)) tim_comp);
#endif
 
      /* Delete timings, that have worst time and bigger size than other */
      j = 1;
      csize = t[0].size;
      for (i = 1; i < nt; i++)
        if (t[i].size < csize)
          t[j++] = t[i];
      nt = j;
 
      cucdebug (1, "Available options\n");
      for (i = 0; i < nt; i++)
        cucdebug (1, "%i:%i,%i: %icyc %.1f\n",
                  t[i].b, t[i].preroll, t[i].unroll, t[i].new_time,
                  t[i].size);
      /* Add results from CSM */
      j = nt;
      for (i = 0; i < saved->bb[b].ntim; i++)
        {
          int i1;
          for (i1 = 0; i1 < nt; i1++)
            {
              t[j] = t[i1];
              t[j].size += saved->bb[b].tim[i].size - timings.size;
              t[j].new_time +=
                saved->bb[b].tim[i].new_time - timings.new_time;
              t[j].nshared = saved->bb[b].tim[i].nshared;
              t[j].shared = saved->bb[b].tim[i].shared;
              if (++j >= MAX_UNROLL * MAX_PREROLL)
                goto full;
            }
        }
 
    full:
      nt = j;
 
      cucdebug (1, "Available options:\n");
      for (i = 0; i < nt; i++)
        cucdebug (1, "%i:%i,%i: %icyc %.1f\n",
                  t[i].b, t[i].preroll, t[i].unroll, t[i].new_time,
                  t[i].size);
 
      /* Sort again with new timings added */
#if HAVE___COMPAR_FN_T
      qsort (t, nt, sizeof (cuc_timings),
             (__compar_fn_t) tim_comp);
#else
      qsort (t, nt, sizeof (cuc_timings),
             (int (*)(const void *, const void *)) tim_comp);
#endif
 
      /* Delete timings, that have worst time and bigger size than other */
      j = 1;
      csize = t[0].size;
      for (i = 1; i < nt; i++)
        if (t[i].size < csize)
          t[j++] = t[i];
      nt = j;
 
      cucdebug (1, "Available options:\n");
      for (i = 0; i < nt; i++)
        cucdebug (1, "%i:%i,%i: %icyc %.1f\n",
                  t[i].b, t[i].preroll, t[i].unroll, t[i].new_time,
                  t[i].size);
 
      if (saved->bb[b].ntim)
        free (saved->bb[b].tim);
      saved->bb[b].ntim = nt;
      assert (saved->bb[b].tim =
              (cuc_timings *) malloc (sizeof (cuc_timings) * nt));
 
      /* Copy options in reverse order -- smallest first */
      for (i = 0; i < nt; i++)
        saved->bb[b].tim[i] = t[nt - 1 - i];
 
      log ("Available options:\n");
      for (i = 0; i < saved->bb[b].ntim; i++)
        {
          log ("%i:pre%i,un%i,sha%i: %icyc %.1f\n",
               saved->bb[b].tim[i].b, saved->bb[b].tim[i].preroll,
               saved->bb[b].tim[i].unroll, saved->bb[b].tim[i].nshared,
               saved->bb[b].tim[i].new_time, saved->bb[b].tim[i].size);
        }
    }
#endif
  return saved;
}
 
/* Utility option formatting functions */
static const char *option_char =
  "?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
/*static */ char *
gen_option (char *s, int bb_no, int f_opt)
{
  if (bb_no >= 0)
    sprintf (s, "%i", bb_no);
  assert (f_opt <= strlen (option_char));
  sprintf (s, "%s%c", s, option_char[f_opt]);
  return s;
}
 
/*static */ void
print_option (int bb_no, int f_opt)
{
  char tmp1[10];
  char tmp2[10];
  sprintf (tmp2, "%s", gen_option (tmp1, bb_no, f_opt));
  PRINTF ("%3s", tmp2);
}
 
static char *
format_func_options (char *s, cuc_func * f)
{
  int b, first = 1;
  *s = '\0';
  for (b = 0; b < f->num_bb; b++)
    if (f->bb[b].selected_tim >= 0)
      {
        char tmp[10];
        sprintf (s, "%s%s%s", s, first ? "" : ",",
                 gen_option (tmp, b, f->bb[b].selected_tim));
        first = 0;
      }
  return s;
}
 
static void
options_cmd (int func_no, cuc_func * f)
{
  int b, i;
  char tmp[30];
  char *name = prof_func[func_no].name;
  PRINTF
    ("-----------------------------------------------------------------------------\n");
  PRINTF ("|%-28s|pre/unrolled|shared|  time  |  gates |old_time|\n",
          strstrip (tmp, name, 28));
  PRINTF ("|                    BASE    |%4i / %4i | %4i |%8i|%8.f|%8i|\n", 1,
          1, 0, f->timings.new_time, f->timings.size, f->orig_time);
  for (b = 0; b < f->num_bb; b++)
    {
      /* Print out results */
      for (i = 1; i < f->bb[b].ntim; i++)
        {                       /* First one is base option */
          int time = f->bb[b].tim[i].new_time - f->timings.new_time;
          double size = f->bb[b].tim[i].size - f->timings.size;
          PRINTF ("|                   ");
          print_option (b, i);
          PRINTF ("      |%4i / %4i | %4i |%+8i|%+8.f|        |\n",
                  f->bb[b].tim[i].preroll, f->bb[b].tim[i].unroll,
                  f->bb[b].tim[i].nshared, time, size);
        }
    }
}
 
/* Generates a function, based on specified parameters */
cuc_func *
generate_function (cuc_func * rf, char *name, char *cut_filename)
{
  int b;
  char tmp[256];
  cuc_timings tt;
  cuc_func *f;
  assert (f = dup_func (rf));
 
  if (cuc_debug >= 2)
    print_cuc_bb (f, "BEFORE_GENERATE");
  log ("Generating function %s.\n", name);
  PRINTF ("Generating function %s.\n", name);
 
  format_func_options (tmp, rf);
  if (strlen (tmp))
    PRINTF ("Applying options: %s\n", tmp);
  else
    PRINTF ("Using basic options.\n");
 
  /* Generate function as specified by options */
  for (b = 0; b < f->num_bb; b++)
    {
      cuc_timings *st;
      if (rf->bb[b].selected_tim < 0)
        continue;
      st = &rf->bb[b].tim[rf->bb[b].selected_tim];
      sprintf (tmp, "%s.bin.bb", name);
      preunroll_bb (&tmp[0], f, &tt, b, st->preroll, st->unroll);
      if (cuc_debug >= 1)
        print_cuc_bb (f, "AFTER_PREUNROLL");
    }
  for (b = 0; b < f->num_bb; b++)
    {
      cuc_timings *st;
      if (rf->bb[b].selected_tim < 0)
        continue;
      st = &rf->bb[b].tim[rf->bb[b].selected_tim];
      if (!st->nshared)
        continue;
      assert (0);
      //csm_gen (f, rf, st->nshared, st->shared);
    }
  add_latches (f);
  if (cuc_debug >= 1)
    print_cuc_bb (f, "AFTER_LATCHES");
  analyse_timings (f, &tt);
 
  sprintf (tmp, "%s%s", cut_filename, name);
  output_verilog (f, tmp, name);
  return f;
}
 
/* Calculates required time, based on selected options */
int
calc_cycles (cuc_func * f)
{
  int b, ntime = f->timings.new_time;
  for (b = 0; b < f->num_bb; b++)
    if (f->bb[b].selected_tim >= 0)
      {
        assert (f->bb[b].selected_tim < f->bb[b].ntim);
        ntime +=
          f->bb[b].tim[f->bb[b].selected_tim].new_time - f->timings.new_time;
      }
  return ntime;
}
 
/* Calculates required size, based on selected options */
double
calc_size (cuc_func * f)
{
  int b;
  double size = f->timings.size;
  for (b = 0; b < f->num_bb; b++)
    if (f->bb[b].selected_tim >= 0)
      {
        assert (f->bb[b].selected_tim < f->bb[b].ntim);
        size += f->bb[b].tim[f->bb[b].selected_tim].size - f->timings.size;
      }
  return size;
}
 
/* Dumps specified function to file (hex) */
unsigned long
extract_function (char *out_fn, unsigned long start_addr)
{
  FILE *fo;
  unsigned long a = start_addr;
  int x = 0;
  assert (fo = fopen (out_fn, "wt+"));
 
  do
    {
      unsigned long d = eval_direct32 (a, 0, 0);
      int index = insn_decode (d);
      assert (index >= 0);
      if (x)
        x++;
      if (strcmp (insn_name (index), "l.jr") == 0)
        x = 1;
      a += 4;
      fprintf (fo, "%08lx\n", d);
    }
  while (x < 2);
 
  fclose (fo);
  return a - 4;
}
 
static cuc_func *func[MAX_FUNCS];
static int func_v[MAX_FUNCS];
 
/* Detects function dependencies and removes  */
static void
set_func_deps ()
{
  int f, b, i, j;
restart:
  for (f = 0; f < prof_nfuncs - 1; f++)
    if (func[f])
      {
        int fused[MAX_FUNCS] = { 0 };
        int c = 0;
        for (b = 0; b < func[f]->num_bb; b++)
          for (i = 0; i < func[f]->bb[b].ninsn; i++)
            {
              cuc_insn *ii = &func[f]->bb[b].insn[i];
              if (ii->index == II_CALL)
                {
                  assert (ii->opt[0] == OPT_CONST);
                  for (j = 0; j < prof_nfuncs - 1; j++)
                    if (func[j] && func[j]->start_addr == ii->op[0])
                      break;
                  if (j >= prof_nfuncs - 1)
                    {
                      log ("%s is calling unknown function, address %08lx\n",
                           prof_func[f].name, ii->op[0]);
                      debug (1,
                             "%s is calling unknown function, address %08lx\n",
                             prof_func[f].name, ii->op[0]);
                      free_func (func[f]);
                      func[f] = NULL;
                      goto restart;
                    }
                  else if (f == j)
                    {
                      log ("%s is recursive, ignoring\n", prof_func[f].name);
                      debug (1, "%s is recursive, ignoring\n",
                             prof_func[f].name);
                      free_func (func[f]);
                      func[f] = NULL;
                      goto restart;
                    }
                  else
                    fused[j]++;
                }
            }
        for (i = 0; i < MAX_FUNCS; i++)
          if (fused[i])
            c++;
        if (func[f]->nfdeps)
          free (func[f]->fdeps);
        func[f]->nfdeps = c;
        func[f]->fdeps = (cuc_func **) malloc (sizeof (cuc_func *) * c);
        for (i = 0, j = 0; i < MAX_FUNCS; i++)
          if (fused[i])
            func[f]->fdeps[j++] = func[i];
      }
 
  /* Detect loops */
  {
    int change;
    for (f = 0; f < MAX_FUNCS; f++)
      if (func[f])
        func[f]->tmp = 0;
    do
      {
        change = 0;
        for (f = 0; f < MAX_FUNCS; f++)
          if (func[f] && !func[f]->tmp)
            {
              int o = 1;
              for (i = 0; i < func[f]->nfdeps; i++)
                if (!func[f]->fdeps[i]->tmp)
                  {
                    o = 0;
                    break;
                  }
              if (o)
                {
                  func[f]->tmp = 1;
                  change = 1;
                }
            }
      }
    while (change);
 
    change = 0;
    for (f = 0; f < MAX_FUNCS; f++)
      if (func[f] && !func[f]->tmp)
        {
          free_func (func[f]);
          func[f] = NULL;
          change = 1;
        }
    if (change)
      goto restart;
  }
}
 
void
main_cuc (char *filename)
{
  int i, j;
  char tmp1[256];
  char filename_cut[256];
#if 0                           /* Select prefix, based on binary program name */
  for (i = 0; i < sizeof (filename_cut); i++)
    {
      if (isalpha (filename[i]))
        filename_cut[i] = filename[i];
      else
        {
          filename_cut[i] = '\0';
          break;
        }
    }
#else
  strcpy (filename_cut, "cu");
#endif
 
  PRINTF ("Entering OpenRISC Custom Unit Compiler command prompt\n");
  PRINTF ("Using profile file \"%s\" and memory profile file \"%s\".\n",
          config.sim.prof_fn, config.sim.mprof_fn);
  sprintf (tmp1, "%s.log", filename_cut);
  PRINTF ("Analyzing. (log file \"%s\").\n", tmp1);
  assert (flog = fopen (tmp1, "wt+"));
 
  /* Loads in the specified timings table */
  PRINTF ("Using timings from \"%s\" at %s\n", config.cuc.timings_fn,
          generate_time_pretty (tmp1, config.sim.clkcycle_ps));
  load_timing_table (config.cuc.timings_fn);
  runtime.cuc.cycle_duration = 1000. * config.sim.clkcycle_ps;
  PRINTF ("Multicycle logic %s, bursts %s, %s memory order.\n",
          config.cuc.no_multicycle ? "OFF" : "ON",
          config.cuc.enable_bursts ? "ON" : "OFF",
          config.cuc.memory_order ==
          MO_NONE ? "no" : config.cuc.memory_order ==
          MO_WEAK ? "weak" : config.cuc.memory_order ==
          MO_STRONG ? "strong" : "exact");
 
  prof_set (1, 0);
  assert (prof_acquire (config.sim.prof_fn) == 0);
 
  if (config.cuc.calling_convention)
    PRINTF ("Assuming OpenRISC standard calling convention.\n");
 
  /* Try all functions except "total" */
  for (i = 0; i < prof_nfuncs - 1; i++)
    {
      long orig_time;
      unsigned long start_addr, end_addr;
      orig_time = prof_func[i].cum_cycles;
      start_addr = prof_func[i].addr;
 
      /* Extract the function from the binary */
      sprintf (tmp1, "%s.bin", prof_func[i].name);
      end_addr = extract_function (tmp1, start_addr);
 
      log ("Testing function %s (%08lx - %08lx)\n", prof_func[i].name,
           start_addr, end_addr);
      PRINTF ("Testing function %s (%08lx - %08lx)\n", prof_func[i].name,
              start_addr, end_addr);
      func[i] =
        analyse_function (prof_func[i].name, orig_time, start_addr, end_addr,
                          config.cuc.memory_order, prof_func[i].calls);
      func_v[i] = 0;
    }
  set_func_deps ();
 
  while (1)
    {
      char *s;
    wait_command:
      PRINTF ("(cuc) ");
      fflush (stdout);
    wait_command_empty:
      s = fgets (tmp1, sizeof tmp1, stdin);
      usleep (100);
      if (!s)
        goto wait_command_empty;
      for (s = tmp1; *s != '\0' && *s != '\n' && *s != '\r'; s++);
      *s = '\0';
 
      /* quit command */
      if (strcmp (tmp1, "q") == 0 || strcmp (tmp1, "quit") == 0)
        {
          /* Delete temporary files */
          for (i = 0; i < prof_nfuncs - 1; i++)
            {
              sprintf (tmp1, "%s.bin", prof_func[i].name);
              log ("Deleting temporary file %s %s\n", tmp1,
                   remove (tmp1) ? "FAILED" : "OK");
              sprintf (tmp1, "%s.bin.bb", prof_func[i].name);
              log ("Deleting temporary file %s %s\n", tmp1,
                   remove (tmp1) ? "FAILED" : "OK");
            }
          break;
 
          /* profile command */
        }
      else if (strcmp (tmp1, "p") == 0 || strcmp (tmp1, "profile") == 0)
        {
          int ntime = 0;
          int size = 0;
          PRINTF
            ("-----------------------------------------------------------------------------\n");
          PRINTF
            ("|function name       |calls|avg cycles  |old%%| max. f.  | impr. f.| options |\n");
          PRINTF
            ("|--------------------+-----+------------+----+----------|---------+---------|\n");
          for (j = 0; j < prof_nfuncs; j++)
            {
              int bestcyc = 0, besti = 0;
              char tmp[100];
              for (i = 0; i < prof_nfuncs; i++)
                if (prof_func[i].cum_cycles > bestcyc)
                  {
                    bestcyc = prof_func[i].cum_cycles;
                    besti = i;
                  }
              i = besti;
              PRINTF ("|%-20s|%5li|%12.1f|%3.0f%%| ",
                      strstrip (tmp, prof_func[i].name, 20),
                      prof_func[i].calls,
                      ((double) prof_func[i].cum_cycles / prof_func[i].calls),
                      (100. * prof_func[i].cum_cycles / prof_cycles));
              if (func[i])
                {
                  double f = 1.0;
                  if (func_v[i])
                    {
                      int nt = calc_cycles (func[i]);
                      int s = calc_size (func[i]);
                      f = 1. * func[i]->orig_time / nt;
                      ntime += nt;
                      size += s;
                    }
                  else
                    ntime += prof_func[i].cum_cycles;
                  PRINTF ("%8.1f |%8.1f | %-8s|\n",
                          1.f * prof_func[i].cum_cycles /
                          func[i]->timings.new_time, f,
                          format_func_options (tmp, func[i]));
                }
              else
                {
                  PRINTF ("     N/A |     N/A |     N/A |\n");
                  ntime += prof_func[i].cum_cycles;
                }
              prof_func[i].cum_cycles = -prof_func[i].cum_cycles;
            }
          for (i = 0; i < prof_nfuncs; i++)
            prof_func[i].cum_cycles = -prof_func[i].cum_cycles;
          PRINTF
            ("-----------------------------------------------------------------------------\n");
          PRINTF
            ("Total %i cycles (was %i), total added gates = %i. Speed factor %.1f\n",
             ntime, prof_cycles, size, 1. * prof_cycles / ntime);
 
          /* debug command */
        }
      else if (strncmp (tmp1, "d", 1) == 0 || strncmp (tmp1, "debug", 5) == 0)
        {
          sscanf (tmp1, "%*s %i", &cuc_debug);
          if (cuc_debug < 0)
            cuc_debug = 0;
          if (cuc_debug > 9)
            cuc_debug = 9;
 
          /* generate command */
        }
      else if (strcmp (tmp1, "g") == 0 || strcmp (tmp1, "generate") == 0)
        {
          /* check for function dependencies */
          for (i = 0; i < prof_nfuncs; i++)
            if (func[i])
              func[i]->tmp = func_v[i];
          for (i = 0; i < prof_nfuncs; i++)
            if (func[i])
              for (j = 0; j < func[i]->nfdeps; j++)
                if (!func[i]->fdeps[j] || !func[i]->fdeps[j]->tmp)
                  {
                    PRINTF
                      ("Function %s must be selected for translation (required by %s)\n",
                       prof_func[j].name, prof_func[i].name);
                    goto wait_command;
                  }
          for (i = 0; i < prof_nfuncs; i++)
            if (func[i] && func_v[i])
              generate_function (func[i], prof_func[i].name, filename_cut);
          generate_main (prof_nfuncs, func, filename_cut);
 
          /* list command */
        }
      else if (strcmp (tmp1, "l") == 0 || strcmp (tmp1, "list") == 0)
        {
          /* check for function dependencies */
          for (i = 0; i < prof_nfuncs; i++)
            if (func_v[i])
              {
                PRINTF ("%s\n", prof_func[i].name);
              }
 
          /* selectall command */
        }
      else if (strcmp (tmp1, "sa") == 0 || strcmp (tmp1, "selectall") == 0)
        {
          int f;
          for (f = 0; f < prof_nfuncs; f++)
            if (func[f])
              {
                func_v[f] = 1;
                PRINTF ("Function %s selected for translation.\n",
                        prof_func[f].name);
              }
 
          /* select command */
        }
      else if (strncmp (tmp1, "s", 1) == 0
               || strncmp (tmp1, "select", 6) == 0)
        {
          char tmp[50], ch;
          int p, o, b, f;
          p = sscanf (tmp1, "%*s %s %i%c", tmp, &b, &ch);
          if (p < 1)
            PRINTF ("Invalid parameters.\n");
          else
            {
              /* Check if we have valid option */
              for (f = 0; f < prof_nfuncs; f++)
                if (strcmp (prof_func[f].name, tmp) == 0 && func[f])
                  break;
              if (f < prof_nfuncs)
                {
                  if (p == 1)
                    {
                      if (func[f])
                        {
                          func_v[f] = 1;
                          PRINTF ("Function %s selected for translation.\n",
                                  prof_func[f].name);
                        }
                      else
                        PRINTF ("Function %s not suitable for translation.\n",
                                prof_func[f].name);
                    }
                  else
                    {
                      if (!func_v[f])
                        PRINTF
                          ("Function %s not yet selected for translation.\n",
                           prof_func[f].name);
                      if (p < 3)
                        goto invalid_option;
                      for (o = 0;
                           option_char[o] != '\0' && option_char[o] != ch;
                           o++);
                      if (!option_char[o])
                        goto invalid_option;
                      if (b < 0 || b >= func[f]->num_bb)
                        goto invalid_option;
                      if (o < 0 || o >= func[f]->bb[b].ntim)
                        goto invalid_option;
 
                      /* select an option */
                      func[f]->bb[b].selected_tim = o;
                      if (func[f]->bb[b].tim[o].nshared)
                        {
                          PRINTF ("Option has shared instructions: ");
                          print_shared (func[f], func[f]->bb[b].tim[o].shared,
                                        func[f]->bb[b].tim[o].nshared);
                          PRINTF ("\n");
                        }
                      goto wait_command;
                    invalid_option:
                      PRINTF ("Invalid option.\n");
                    }
                }
              else
                PRINTF ("Invalid function.\n");
            }
 
          /* unselect command */
        }
      else if (strncmp (tmp1, "u", 1) == 0
               || strncmp (tmp1, "unselect", 8) == 0)
        {
          char tmp[50], ch;
          int p, o, b, f;
          p = sscanf (tmp1, "%*s %s %i%c", tmp, &b, &ch);
          if (p < 1)
            PRINTF ("Invalid parameters.\n");
          else
            {
              /* Check if we have valid option */
              for (f = 0; f < prof_nfuncs; f++)
                if (strcmp (prof_func[f].name, tmp) == 0 && func[f])
                  break;
              if (f < prof_nfuncs)
                {
                  if (p == 1)
                    {
                      if (func[f])
                        {
                          func_v[f] = 0;
                          PRINTF ("Function %s unselected for translation.\n",
                                  prof_func[f].name);
                        }
                      else
                        PRINTF ("Function %s not suitable for translation.\n",
                                prof_func[f].name);
                    }
                  else
                    {
                      if (p < 3)
                        goto invalid_option;
                      for (o = 0;
                           option_char[o] != '\0' && option_char[o] != ch;
                           o++);
                      if (!option_char[o])
                        goto invalid_option;
                      if (b < 0 || b >= func[f]->num_bb)
                        goto invalid_option;
                      if (o < 0 || o >= func[f]->bb[b].ntim)
                        goto invalid_option;
 
                      /* select an option */
                      func[f]->bb[b].selected_tim = -1;
                    }
                }
              else
                PRINTF ("Invalid function.\n");
            }
 
          /* options command */
        }
      else if (strcmp (tmp1, "o") == 0 || strcmp (tmp1, "options") == 0)
        {
          int any = 0;
          PRINTF ("Available options:\n");
          for (i = 0; i < prof_nfuncs; i++)
            if (func[i])
              {
                options_cmd (i, func[i]);
                any = 1;
              }
          if (any)
            PRINTF
              ("-----------------------------------------------------------------------------\n");
          else
            PRINTF ("Sorry. No available options.\n");
 
          /* Ignore empty string */
        }
      else if (strcmp (tmp1, "") == 0)
        {
 
          /* help command */
        }
      else
        {
          if (strcmp (tmp1, "h") != 0 && strcmp (tmp1, "help") != 0)
            PRINTF ("Unknown command.\n");
          PRINTF ("OpenRISC Custom Unit Compiler command prompt\n");
          PRINTF ("Available commands:\n");
          PRINTF ("  h | help                   displays this help\n");
          PRINTF ("  q | quit                   returns to or1ksim prompt\n");
          PRINTF
            ("  p | profile                displays function profiling\n");
          PRINTF ("  d | debug #                sets debug level (0-9)\n");
          PRINTF
            ("  o | options                displays available options\n");
          PRINTF
            ("  s | select func [option]   selects an option/function\n");
          PRINTF
            ("  u | unselect func [option] unselects an option/function\n");
          PRINTF ("  g | generate               generates verilog file\n");
          PRINTF
            ("  l | list                   displays selected functions\n");
        }
    }
 
  /* Dispose memory */
  for (i = 0; i < prof_nfuncs - 1; i++)
    if (func[i])
      free_func (func[i]);
 
  fclose (flog);
}
 
/*----------------------------------------------------[ CUC Configuration ]---*/
 
/*---------------------------------------------------------------------------*/
/*!Set the memory order
 
   Value must be one of none, weak, strong or exact. Invalid values are
   ignored with a warning.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
static void
cuc_memory_order (union param_val val, void *dat)
{
  if (strcasecmp (val.str_val, "none") == 0)
    {
      config.cuc.memory_order = MO_NONE;
    }
  else if (strcasecmp (val.str_val, "weak") == 0)
    {
      config.cuc.memory_order = MO_WEAK;
    }
  else if (strcasecmp (val.str_val, "strong") == 0)
    {
      config.cuc.memory_order = MO_STRONG;
    }
  else if (strcasecmp (val.str_val, "exact") == 0)
    {
      config.cuc.memory_order = MO_EXACT;
    }
  else
    {
      fprintf (stderr, "Warning: CUC memory order invalid. Ignored");
    }
}                               /* cuc_memory_order() */
 
 
static void
cuc_calling_conv (union param_val val, void *dat)
{
  config.cuc.calling_convention = val.int_val;
}
 
static void
cuc_enable_bursts (union param_val val, void *dat)
{
  config.cuc.enable_bursts = val.int_val;
}
 
static void
cuc_no_multicycle (union param_val val, void *dat)
{
  config.cuc.no_multicycle = val.int_val;
}
 
 
/*---------------------------------------------------------------------------*/
/*!Set the timings file
 
   Free any existing string.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
static void
cuc_timings_fn (union param_val val, void *dat)
{
  if (NULL != config.cuc.timings_fn)
    {
      free (config.cuc.timings_fn);
    }
 
  config.cuc.timings_fn = strdup (val.str_val);
 
}                               /* cuc_timings_fn() */
 
 
void
reg_cuc_sec ()
{
  struct config_section *sec = reg_config_sec ("cuc", NULL, NULL);
 
  reg_config_param (sec, "memory_order", paramt_word, cuc_memory_order);
  reg_config_param (sec, "calling_convention", paramt_int, cuc_calling_conv);
  reg_config_param (sec, "enable_bursts", paramt_int, cuc_enable_bursts);
  reg_config_param (sec, "no_multicycle", paramt_int, cuc_no_multicycle);
  reg_config_param (sec, "timings_file", paramt_str, cuc_timings_fn);
  reg_config_param (sec, "timings_fn", paramt_str, cuc_timings_fn);
}

Line No.	Rev	Author	Line
1	1244	hpanther	`/* cuc.c -- OpenRISC Custom Unit Compiler`
2
3	1748	jeremybenn	`Copyright (C) 2002 Marko Mlinar, markom@opencores.org`
4			`Copyright (C) 2008 Embecosm Limited`
5
6			`Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>`
7
8			`This file is part of OpenRISC 1000 Architectural Simulator.`
9
10			`This program is free software; you can redistribute it and/or modify it`
11			`under the terms of the GNU General Public License as published by the Free`
12			`Software Foundation; either version 3 of the License, or (at your option)`
13			`any later version.`
14
15			`This program is distributed in the hope that it will be useful, but WITHOUT`
16			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
17			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for`
18			`more details.`
19
20			`You should have received a copy of the GNU General Public License along`
21			`with this program. If not, see <http://www.gnu.org/licenses/>. */`
22
23			`/* This program is commented throughout in a fashion suitable for processing`
24			`with Doxygen. */`
25
26	1244	hpanther	`/* Main file, including code optimization and command prompt */`
27
28	1308	phoenix
29	1748	jeremybenn	`/* Autoconf and/or portability configuration */`
30	1350	nogj	`#include "config.h"`
31	1748	jeremybenn	`#include "port.h"`
32	1350	nogj
33	1748	jeremybenn	`/* System includes */`
34			`#include <stdlib.h>`
35			`#include <unistd.h>`
36			`#include <assert.h>`
37	1350	nogj
38	1748	jeremybenn	`/* Package includes */`
39			`#include "cuc.h"`
40	1244	hpanther	`#include "sim-config.h"`
41	1748	jeremybenn	`#include "profiler.h"`
42	1244	hpanther	`#include "insn.h"`
43			`#include "opcode/or32.h"`
44			`#include "parse.h"`
45	1748	jeremybenn	`#include "verilog.h"`
46	1308	phoenix	`#include "debug.h"`
47	1244	hpanther
48			`FILE *flog;`
49			`int cuc_debug = 0;`
50
51			`/* Last used registers by software convention */`
52			`/* Note that r11 is caller saved register, and we can destroy it.`
53			`Due to CUC architecture we must always return something, even garbage (so that`
54			`caller knows, we are finished, when we send acknowledge).`
55			`In case r11 was not used (trivial register assignment) we will remove it later,`
56			`but if we assigned a value to it, it must not be removed, so caller_saved[11] = 0 */`
57			`const int caller_saved[MAX_REGS] = {`
58			`0, 0, 0, 1, 1, 1, 1, 1,`
59			`1, 1, 0, 0, 0, 1, 0, 1,`
60			`0, 1, 0, 1, 0, 1, 0, 1,`
61			`0, 1, 0, 1, 0, 1, 0, 1,`
62	1748	jeremybenn	`1, 1`
63			`};`
64	1244	hpanther
65			`/* Does all known instruction optimizations */`
66	1748	jeremybenn	`void`
67			`cuc_optimize (cuc_func * func)`
68	1244	hpanther	`{`
69			`int modified = 0;`
70			`int first = 1;`
71			`log ("Optimizing.\n");`
72	1748	jeremybenn	`do`
73			`{`
74			`modified = 0;`
75			`clean_deps (func);`
76			`if (cuc_debug >= 6)`
77			`print_cuc_bb (func, "AFTER_CLEAN_DEPS");`
78			`if (optimize_cmovs (func))`
79			`{`
80			`if (cuc_debug >= 6)`
81			`print_cuc_bb (func, "AFTER_OPT_CMOVS");`
82			`modified = 1;`
83			`}`
84			`if (cuc_debug)`
85			`cuc_check (func);`
86			`if (optimize_tree (func))`
87			`{`
88			`if (cuc_debug >= 6)`
89			`print_cuc_bb (func, "AFTER_OPT_TREE1");`
90			`modified = 1;`
91			`}`
92			`if (remove_nops (func))`
93			`{`
94			`if (cuc_debug >= 6)`
95			`print_cuc_bb (func, "NO_NOPS");`
96			`modified = 1;`
97			`}`
98			`if (cuc_debug)`
99			`cuc_check (func);`
100			`if (remove_dead (func))`
101			`{`
102			`if (cuc_debug >= 5)`
103			`print_cuc_bb (func, "AFTER_DEAD");`
104			`modified = 1;`
105			`}`
106			`if (cuc_debug)`
107			`cuc_check (func);`
108			`if (cse (func))`
109			`{`
110			`log ("Common subexpression elimination.\n");`
111			`if (cuc_debug >= 3)`
112			`print_cuc_bb (func, "AFTER_CSE");`
113			`modified = 1;`
114			`}`
115			`if (first)`
116			`{`
117			`insert_conditional_facts (func);`
118			`if (cuc_debug >= 3)`
119			`print_cuc_bb (func, "AFTER_COND_FACT");`
120			`if (cuc_debug)`
121			`cuc_check (func);`
122			`first = 0;`
123			`}`
124			`if (optimize_bb (func))`
125			`{`
126			`if (cuc_debug >= 5)`
127			`print_cuc_bb (func, "AFTER_OPT_BB");`
128			`modified = 1;`
129			`}`
130			`if (cuc_debug)`
131			`cuc_check (func);`
132			`if (remove_nops (func))`
133			`{`
134			`if (cuc_debug >= 6)`
135			`print_cuc_bb (func, "NO_NOPS");`
136			`modified = 1;`
137			`}`
138			`if (remove_dead_bb (func))`
139			`{`
140			`if (cuc_debug >= 5)`
141			`print_cuc_bb (func, "AFTER_DEAD_BB");`
142			`modified = 1;`
143			`}`
144			`if (remove_trivial_regs (func))`
145			`{`
146			`if (cuc_debug >= 2)`
147			`print_cuc_bb (func, "AFTER_TRIVIAL");`
148			`modified = 1;`
149			`}`
150			`if (remove_nops (func))`
151			`{`
152			`if (cuc_debug >= 6)`
153			`print_cuc_bb (func, "NO_NOPS");`
154			`modified = 1;`
155			`}`
156			`add_memory_dep (func, func->memory_order);`
157			`if (cuc_debug >= 7)`
158			`print_cuc_bb (func, "AFTER_MEMORY_DEP");`
159			`add_data_dep (func);`
160			`if (cuc_debug >= 8)`
161			`print_cuc_bb (func, "AFTER_DATA_DEP");`
162			`if (schedule_memory (func, func->memory_order))`
163			`{`
164			`if (cuc_debug >= 7)`
165			`print_cuc_bb (func, "AFTER_SCHEDULE_MEM");`
166			`modified = 1;`
167			`}`
168	1244	hpanther	`}`
169	1748	jeremybenn	`while (modified);`
170	1244	hpanther	`set_io (func);`
171			`#if 0`
172			`detect_max_values (func);`
173	1748	jeremybenn	`if (cuc_debug >= 5)`
174			`print_cuc_bb (func, "AFTER_MAX_VALUES");`
175	1244	hpanther	`#endif`
176			`}`
177
178			`/* Pre/unrolls basic block and optimizes it */`
179	1748	jeremybenn	`cuc_timings *`
180			`preunroll_bb (char bb_filename, cuc_func f, cuc_timings * timings, int b,`
181			`int i, int j)`
182	1244	hpanther	`{`
183			`cuc_func *func;`
184			`cucdebug (2, "BB%i unroll %i times preroll %i times\n", b, j, i);`
185			`log ("BB%i unroll %i times preroll %i times\n", b, j, i);`
186			`func = preunroll_loop (f, b, i, j, bb_filename);`
187	1748	jeremybenn	`if (cuc_debug >= 2)`
188			`print_cuc_bb (func, "AFTER_PREUNROLL");`
189	1244	hpanther	`cuc_optimize (func);`
190			`analyse_timings (func, timings);`
191
192			`cucdebug (2, "new_time = %i, old_time = %i, size = %f\n",`
193	1748	jeremybenn	`timings->new_time, func->orig_time, timings->size);`
194	1244	hpanther	`log ("new time = %icyc, old_time = %icyc, size = %.0f gates\n",`
195	1748	jeremybenn	`timings->new_time, func->orig_time, timings->size);`
196	1244	hpanther	`//output_verilog (func, argv[1]);`
197			`free_func (func);`
198			`timings->b = b;`
199			`timings->unroll = j;`
200			`timings->preroll = i;`
201			`timings->nshared = 0;`
202			`return timings;`
203			`}`
204
205	1751	jeremybenn
206	1244	hpanther	`/* Simple comparison function */`
207	1748	jeremybenn	`int`
208			`tim_comp (cuc_timings * a, cuc_timings * b)`
209	1244	hpanther	`{`
210	1748	jeremybenn	`if (a->new_time < b->new_time)`
211			`return -1;`
212			`else if (a->new_time > b->new_time)`
213			`return 1;`
214			`else`
215			`return 0;`
216	1244	hpanther	`}`
217
218			`/* Analyses function; done when cuc command is entered in (sim) prompt */`
219	1748	jeremybenn	`cuc_func *`
220			`analyse_function (char *module_name, long orig_time,`
221			`unsigned long start_addr, unsigned long end_addr,`
222			`int memory_order, int num_runs)`
223	1244	hpanther	`{`
224			`cuc_timings timings;`
225			`cuc_func func = (cuc_func ) malloc (sizeof (cuc_func));`
226			`cuc_func *saved;`
227			`int b, i, j;`
228			`char tmp1[256];`
229			`char tmp2[256];`
230
231			`func->orig_time = orig_time;`
232			`func->start_addr = start_addr;`
233			`func->end_addr = end_addr;`
234			`func->memory_order = memory_order;`
235			`func->nfdeps = 0;`
236			`func->fdeps = NULL;`
237			`func->num_runs = num_runs;`
238
239			`sprintf (tmp1, "%s.bin", module_name);`
240			`cucdebug (2, "Loading %s.bin\n", module_name);`
241	1748	jeremybenn	`if (cuc_load (tmp1))`
242			`{`
243			`free (func);`
244			`return NULL;`
245			`}`
246	1244	hpanther
247			`log ("Detecting basic blocks\n");`
248			`detect_bb (func);`
249	1748	jeremybenn	`if (cuc_debug >= 2)`
250			`print_cuc_insns ("WITH_BB_LIMITS", 0);`
251	1244	hpanther
252			`//sprintf (tmp1, "%s.bin.mp", module_name);`
253			`sprintf (tmp2, "%s.bin.bb", module_name);`
254			`generate_bb_seq (func, config.sim.mprof_fn, tmp2);`
255	1748	jeremybenn	`log ("Assuming %i clk cycle load (%i cyc burst)\n", runtime.cuc.mdelay[0],`
256			`runtime.cuc.mdelay[2]);`
257			`log ("Assuming %i clk cycle store (%i cyc burst)\n", runtime.cuc.mdelay[1],`
258			`runtime.cuc.mdelay[3]);`
259
260	1244	hpanther	`build_bb (func);`
261	1748	jeremybenn	`if (cuc_debug >= 5)`
262			`print_cuc_bb (func, "AFTER_BUILD_BB");`
263	1244	hpanther	`reg_dep (func);`
264
265			`log ("Detecting dependencies\n");`
266	1748	jeremybenn	`if (cuc_debug >= 2)`
267			`print_cuc_bb (func, "AFTER_REG_DEP");`
268	1244	hpanther	`cuc_optimize (func);`
269	1748	jeremybenn
270	1244	hpanther	`#if 0`
271			`csm (func);`
272			`#endif`
273			`assert (saved = dup_func (func));`
274
275			`timings.preroll = timings.unroll = 1;`
276			`timings.nshared = 0;`
277
278			`add_latches (func);`
279	1748	jeremybenn	`if (cuc_debug >= 1)`
280			`print_cuc_bb (func, "AFTER_LATCHES");`
281	1244	hpanther	`analyse_timings (func, &timings);`
282
283			`free_func (func);`
284			`log ("Base option: pre%i,un%i,sha%i: %icyc %.1f\n",`
285	1748	jeremybenn	`timings.preroll, timings.unroll, timings.nshared, timings.new_time,`
286			`timings.size);`
287	1244	hpanther	`saved->timings = timings;`
288	1748	jeremybenn
289	1244	hpanther	`#if 1`
290			`/* detect and unroll simple loops */`
291	1748	jeremybenn	`for (b = 0; b < saved->num_bb; b++)`
292			`{`
293			`cuc_timings t[MAX_UNROLL * MAX_PREROLL];`
294			`cuc_timings *ut;`
295			`cuc_timings *cut = &t[0];`
296			`int nt = 1;`
297			`double csize;`
298			`saved->bb[b].selected_tim = -1;`
299	1244	hpanther
300	1748	jeremybenn	`/* Is it a loop? */`
301			`if (saved->bb[b].next[0] != b && saved->bb[b].next[1] != b)`
302			`continue;`
303			`log ("Found loop at BB%x. Trying to unroll.\n", b);`
304			`t[0] = timings;`
305			`t[0].b = b;`
306			`t[0].preroll = 1;`
307			`t[0].unroll = 1;`
308			`t[0].nshared = 0;`
309	1244	hpanther
310	1748	jeremybenn	`sprintf (tmp1, "%s.bin.bb", module_name);`
311			`i = 1;`
312			`do`
313			`{`
314			`cuc_timings *pt;`
315			`cuc_timings *cpt = cut;`
316			`j = 1;`
317	1244	hpanther
318	1748	jeremybenn	`do`
319			`{`
320			`pt = cpt;`
321			`cpt = preunroll_bb (tmp1, saved, &t[nt++], b, ++j, i);`
322			`}`
323			`while (j <= MAX_PREROLL && pt->new_time > cpt->new_time);`
324			`i++;`
325			`ut = cut;`
326			`cut = preunroll_bb (tmp1, saved, &t[nt++], b, 1, i);`
327			`}`
328			`while (i <= MAX_UNROLL && ut->new_time > cut->new_time);`
329
330			`/* Sort the timings */`
331	1244	hpanther	`#if 0`
332	1748	jeremybenn	`if (cuc_debug >= 3)`
333			`for (i = 0; i < nt; i++)`
334			`PRINTF ("%i:%i,%i: %icyc\n",`
335			`t[i].b, t[i].preroll, t[i].unroll, t[i].new_time);`
336	1244	hpanther	`#endif`
337
338	1751	jeremybenn	`#if HAVE___COMPAR_FN_T`
339	1748	jeremybenn	`qsort (t, nt, sizeof (cuc_timings),`
340	1751	jeremybenn	`(__compar_fn_t) tim_comp);`
341			`#else`
342			`qsort (t, nt, sizeof (cuc_timings),`
343			`(int () (const void , const void *)) tim_comp);`
344			`#endif`
345	1244	hpanther
346	1748	jeremybenn	`/* Delete timings, that have worst time and bigger size than other */`
347			`j = 1;`
348			`csize = t[0].size;`
349			`for (i = 1; i < nt; i++)`
350			`if (t[i].size < csize)`
351			`t[j++] = t[i];`
352			`nt = j;`
353	1244	hpanther
354	1748	jeremybenn	`cucdebug (1, "Available options\n");`
355			`for (i = 0; i < nt; i++)`
356			`cucdebug (1, "%i:%i,%i: %icyc %.1f\n",`
357			`t[i].b, t[i].preroll, t[i].unroll, t[i].new_time,`
358			`t[i].size);`
359			`/* Add results from CSM */`
360			`j = nt;`
361			`for (i = 0; i < saved->bb[b].ntim; i++)`
362			`{`
363			`int i1;`
364			`for (i1 = 0; i1 < nt; i1++)`
365			`{`
366			`t[j] = t[i1];`
367			`t[j].size += saved->bb[b].tim[i].size - timings.size;`
368			`t[j].new_time +=`
369			`saved->bb[b].tim[i].new_time - timings.new_time;`
370			`t[j].nshared = saved->bb[b].tim[i].nshared;`
371			`t[j].shared = saved->bb[b].tim[i].shared;`
372			`if (++j >= MAX_UNROLL * MAX_PREROLL)`
373			`goto full;`
374			`}`
375			`}`
376	1244	hpanther
377	1748	jeremybenn	`full:`
378			`nt = j;`
379	1244	hpanther
380	1748	jeremybenn	`cucdebug (1, "Available options:\n");`
381			`for (i = 0; i < nt; i++)`
382			`cucdebug (1, "%i:%i,%i: %icyc %.1f\n",`
383			`t[i].b, t[i].preroll, t[i].unroll, t[i].new_time,`
384			`t[i].size);`
385	1244	hpanther
386	1748	jeremybenn	`/* Sort again with new timings added */`
387	1751	jeremybenn	`#if HAVE___COMPAR_FN_T`
388	1748	jeremybenn	`qsort (t, nt, sizeof (cuc_timings),`
389	1751	jeremybenn	`(__compar_fn_t) tim_comp);`
390			`#else`
391			`qsort (t, nt, sizeof (cuc_timings),`
392	1748	jeremybenn	`(int ()(const void , const void *)) tim_comp);`
393	1751	jeremybenn	`#endif`
394	1244	hpanther
395	1748	jeremybenn	`/* Delete timings, that have worst time and bigger size than other */`
396			`j = 1;`
397			`csize = t[0].size;`
398			`for (i = 1; i < nt; i++)`
399			`if (t[i].size < csize)`
400			`t[j++] = t[i];`
401			`nt = j;`
402	1244	hpanther
403	1748	jeremybenn	`cucdebug (1, "Available options:\n");`
404			`for (i = 0; i < nt; i++)`
405			`cucdebug (1, "%i:%i,%i: %icyc %.1f\n",`
406			`t[i].b, t[i].preroll, t[i].unroll, t[i].new_time,`
407			`t[i].size);`
408	1244	hpanther
409	1748	jeremybenn	`if (saved->bb[b].ntim)`
410			`free (saved->bb[b].tim);`
411			`saved->bb[b].ntim = nt;`
412			`assert (saved->bb[b].tim =`
413			`(cuc_timings ) malloc (sizeof (cuc_timings) nt));`
414
415			`/* Copy options in reverse order -- smallest first */`
416			`for (i = 0; i < nt; i++)`
417			`saved->bb[b].tim[i] = t[nt - 1 - i];`
418
419			`log ("Available options:\n");`
420			`for (i = 0; i < saved->bb[b].ntim; i++)`
421			`{`
422			`log ("%i:pre%i,un%i,sha%i: %icyc %.1f\n",`
423			`saved->bb[b].tim[i].b, saved->bb[b].tim[i].preroll,`
424			`saved->bb[b].tim[i].unroll, saved->bb[b].tim[i].nshared,`
425			`saved->bb[b].tim[i].new_time, saved->bb[b].tim[i].size);`
426			`}`
427	1244	hpanther	`}`
428			`#endif`
429			`return saved;`
430			`}`
431
432			`/* Utility option formatting functions */`
433	1748	jeremybenn	`static const char *option_char =`
434			`"?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";`
435	1244	hpanther
436	1748	jeremybenn	`/static / char *`
437			`gen_option (char *s, int bb_no, int f_opt)`
438	1244	hpanther	`{`
439	1748	jeremybenn	`if (bb_no >= 0)`
440			`sprintf (s, "%i", bb_no);`
441	1244	hpanther	`assert (f_opt <= strlen (option_char));`
442			`sprintf (s, "%s%c", s, option_char[f_opt]);`
443			`return s;`
444			`}`
445
446	1748	jeremybenn	`/static / void`
447			`print_option (int bb_no, int f_opt)`
448	1244	hpanther	`{`
449			`char tmp1[10];`
450			`char tmp2[10];`
451			`sprintf (tmp2, "%s", gen_option (tmp1, bb_no, f_opt));`
452			`PRINTF ("%3s", tmp2);`
453			`}`
454
455	1748	jeremybenn	`static char *`
456			`format_func_options (char s, cuc_func f)`
457	1244	hpanther	`{`
458			`int b, first = 1;`
459			`*s = '\0';`
460			`for (b = 0; b < f->num_bb; b++)`
461	1748	jeremybenn	`if (f->bb[b].selected_tim >= 0)`
462			`{`
463			`char tmp[10];`
464			`sprintf (s, "%s%s%s", s, first ? "" : ",",`
465			`gen_option (tmp, b, f->bb[b].selected_tim));`
466			`first = 0;`
467			`}`
468	1244	hpanther	`return s;`
469			`}`
470
471	1748	jeremybenn	`static void`
472			`options_cmd (int func_no, cuc_func * f)`
473	1244	hpanther	`{`
474			`int b, i;`
475			`char tmp[30];`
476			`char *name = prof_func[func_no].name;`
477	1748	jeremybenn	`PRINTF`
478			`("-----------------------------------------------------------------------------\n");`
479	1244	hpanther	`PRINTF ("\|%-28s\|pre/unrolled\|shared\| time \| gates \|old_time\|\n",`
480	1748	jeremybenn	`strstrip (tmp, name, 28));`
481			`PRINTF ("\| BASE \|%4i / %4i \| %4i \|%8i\|%8.f\|%8i\|\n", 1,`
482			`1, 0, f->timings.new_time, f->timings.size, f->orig_time);`
483			`for (b = 0; b < f->num_bb; b++)`
484			`{`
485			`/* Print out results */`
486			`for (i = 1; i < f->bb[b].ntim; i++)`
487			`{ /* First one is base option */`
488			`int time = f->bb[b].tim[i].new_time - f->timings.new_time;`
489			`double size = f->bb[b].tim[i].size - f->timings.size;`
490			`PRINTF ("\| ");`
491			`print_option (b, i);`
492			`PRINTF (" \|%4i / %4i \| %4i \|%+8i\|%+8.f\| \|\n",`
493			`f->bb[b].tim[i].preroll, f->bb[b].tim[i].unroll,`
494			`f->bb[b].tim[i].nshared, time, size);`
495			`}`
496	1244	hpanther	`}`
497			`}`
498
499			`/* Generates a function, based on specified parameters */`
500	1748	jeremybenn	`cuc_func *`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [or1ksim/] [cuc/] [cuc.c] - Blame information for rev 1775