Subversion Repositories openrisc

/* mprofiler.c -- memory profiling utility
 
   Copyright (C) 2002 Marko Mlinar, markom@opencores.org
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
   Copyright (C) 2008 Embecosm Limited
 
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of Or1ksim, the 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. */
 
 
/* Autoconf and/or portability configuration */
#include "config.h"
#include "port.h"
 
/* System includes */
#include <stdlib.h>
#include <regex.h>
 
/* Package includes */
#include "mprofiler.h"
#include "sim-config.h"
#include "argtable2.h"
#include "support/profile.h"
 
/* output modes */
#define MODE_DETAIL     0
#define MODE_PRETTY     1
#define MODE_ACCESS     2
#define MODE_WIDTH      3
 
/* Input buffer size */
#define BUF_SIZE        256
 
/* HASH */
#define HASH_SIZE       0x10000
#define HASH_FUNC(x)    ((x) & 0xffff)
 
/*! Hash table data structure */
static struct memory_hash
{
  struct memory_hash *next;
  oraddr_t            addr;
  unsigned long       cnt[3];		/* Various counters */
} *hash[HASH_SIZE];
 
/*! Groups size -- how much addresses should be joined together */
static int  group_bits = 2;
 
/*! Start address */
static oraddr_t  start_addr = 0;
 
/*! End address */
static oraddr_t  end_addr = 0xffffffff;
 
/* File to read from */
static FILE *fprof = 0;
 
static void
hash_add (oraddr_t addr, int index)
{
  struct memory_hash *h = hash[HASH_FUNC (addr)];
  while (h && h->addr != addr)
    h = h->next;
 
  if (!h)
    {
      h = (struct memory_hash *) malloc (sizeof (struct memory_hash));
      h->next = hash[HASH_FUNC (addr)];
      hash[HASH_FUNC (addr)] = h;
      h->addr = addr;
      h->cnt[0] = h->cnt[1] = h->cnt[2] = 0;
    }
  h->cnt[index]++;
}
 
 
static unsigned long
hash_get (oraddr_t addr, int index)
{
  struct memory_hash *h = hash[HASH_FUNC (addr)];
  while (h && h->addr != addr)
    h = h->next;
 
  if (!h)
    return 0;
  return h->cnt[index];
}
 
static void
init ()
{
  int i;
  for (i = 0; i < HASH_SIZE; i++)
    hash[i] = NULL;
}
 
static void
read_file (FILE * f, int mode)
{
  struct mprofentry_struct buf[BUF_SIZE];
  int num_read;
  do
    {
      int i;
      num_read = fread (buf, sizeof (struct mprofentry_struct), BUF_SIZE, f);
      for (i = 0; i < num_read; i++)
	if (buf[i].addr >= start_addr && buf[i].addr <= end_addr)
	  {
	    int index;
	    unsigned t = buf[i].type;
	    if (t > 64)
	      {
		PRINTF ("!");
		t = 0;
	      }
	    if (mode == MODE_WIDTH)
	      t >>= 3;
	    else
	      t &= 0x7;
 
	    switch (t)
	      {
	      case 1:
		index = 0;
		break;
	      case 2:
		index = 1;
		break;
	      case 4:
		index = 2;
		break;
	      default:
		index = 0;
		PRINTF ("!!!!");
		break;
	      }
	    hash_add (buf[i].addr >> group_bits, index);
	  }
    }
  while (num_read > 0);
}
 
static int
nbits (unsigned long a)
{
  int cnt = 0;
  int b = a;
  if (!a)
    return 0;
 
  while (a)
    a >>= 1, cnt++;
  if (cnt > 1 && ((b >> (cnt - 2)) & 1))
    cnt = cnt * 2 + 1;
  else
    cnt *= 2;
 
  return cnt - 1;
}
 
static void
printout (int mode)
{
  oraddr_t addr = start_addr & ~((1 << group_bits) - 1);
  PRINTF ("start = %" PRIxADDR " (%" PRIxADDR "); end = %" PRIxADDR
	  "; group_bits = %08x\n", start_addr, addr, end_addr,
	  (1 << group_bits) - 1);
  for (; addr <= end_addr; addr += (1 << group_bits))
    {
      int i;
      unsigned long a = hash_get (addr >> group_bits, 0);
      unsigned long b = hash_get (addr >> group_bits, 1);
      unsigned long c = hash_get (addr >> group_bits, 2);
      PRINTF ("%" PRIxADDR ":", addr);
      switch (mode)
	{
	case MODE_DETAIL:
	  if (a)
	    PRINTF (" %10li R", a);
	  else
	    PRINTF ("            R");
	  if (b)
	    PRINTF (" %10li W", b);
	  else
	    PRINTF ("            W");
	  if (c)
	    PRINTF (" %10li F", c);
	  else
	    PRINTF ("            F");
	  break;
	case MODE_ACCESS:
	  PRINTF (" %10li", a + b + c);
	  break;
	case MODE_PRETTY:
	  PRINTF (" %10li ", a + b + c);
	  for (i = 0; i < nbits (a + b + c); i++)
	    PRINTF ("#");
	  break;
	case MODE_WIDTH:
	  if (a)
	    PRINTF (" %10li B", a);
	  else
	    PRINTF ("            B");
	  if (b)
	    PRINTF (" %10li H", b);
	  else
	    PRINTF ("            H");
	  if (c)
	    PRINTF (" %10li W", c);
	  else
	    PRINTF ("            W");
	  break;
	}
      PRINTF ("\n");
      if (addr >= addr + (1 << group_bits))
	break;			/* Overflow? */
    }
}
 
/*---------------------------------------------------------------------------*/
/*! Parse the arguments for the profiling utility
 
    Updated by Jeremy Bennett to use argtable2. Also has an option just to
    print help, for use with the CLI.
 
    @param[in] argc       Number of command args
    @param[in] argv       Vector of the command args
    @param[in] just_help  If 1 (true), ignore argc & argv and just print out
                          the help message without parsing args
 
    @return  0 on success, 1 on failure                                      */
/*---------------------------------------------------------------------------*/
int
main_mprofiler (int argc, char *argv[], int just_help)
{
  struct arg_lit *vercop;
  struct arg_lit *help;
  struct arg_rex *mode_arg;
  struct arg_int *group;
  struct arg_file *prof_file;
  struct arg_int *from;
  struct arg_int *to;
  struct arg_end *end;
 
  void *argtab[8];
  int nerrors;
 
  int mode = MODE_DETAIL;
 
  /* Specify each argument, with fallback values */
  vercop = arg_lit0 ("v", "version", "version and copyright notice");
  help = arg_lit0 ("h", "help", "print this help message");
  mode_arg = arg_rex0 ("m", "mode",
		       "(detailed|d)|(pretty|p)|(access|a)|"
		       "(width|w)", "<m>", REG_ICASE,
		       "Output mode (detailed, pretty, access " "or width)");
  mode_arg->sval[0] = "detailed";
  group = arg_int0 ("g", "group", "<n>",
		    "group 2^n bits successive addresses " "together");
  group->ival[0] = 0;
  prof_file = arg_file0 ("f", "filename", "<file>",
			 "data file to analyse (default " "sim.mprofile)");
  prof_file->filename[0] = "sim.mprofile";
  from = arg_int1 (NULL, NULL, "<from>", "start address");
  to = arg_int1 (NULL, NULL, "<to>", "end address");
  end = arg_end (20);
 
  /* Set up the argument table */
  argtab[0] = vercop;
  argtab[1] = help;
  argtab[2] = mode_arg;
  argtab[3] = group;
  argtab[4] = prof_file;
  argtab[5] = from;
  argtab[6] = to;
  argtab[7] = end;
 
  /* If we are just asked for a help message, then we don't parse the
     args. This is used to implement the help function from the CLI. */
  if (just_help)
    {
      printf ("mprofile");
      arg_print_syntax (stdout, argtab, "\n");
      arg_print_glossary (stdout, argtab, "  %-25s %s\n");
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 0;
    }
 
  /* Parse */
  nerrors = arg_parse (argc, argv, argtab);
 
  /* Special case here is if help or version is specified, we ignore any other
     errors and just print the help or version information and then give up. */
  if (vercop->count > 0)
    {
      PRINTF ("OpenRISC 1000 Memory Profiling Utility, version %s\n",
	      PACKAGE_VERSION);
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 0;
    }
 
  if (help->count > 0)
    {
      printf ("Usage: %s ", argv[0]);
      arg_print_syntax (stdout, argtab, "\n");
      arg_print_glossary (stdout, argtab, "  %-25s %s\n");
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 0;
    }
 
  /* Deal with any errors */
  if (0 != nerrors)
    {
      arg_print_errors (stderr, end, "mprofile");
      fprintf (stderr, "Usage: %s ", argv[0]);
      arg_print_syntaxv (stderr, argtab, "\n");
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  /* If version or help is requested, that is all that is printed out */
  /* Sort out the mode */
  if ((0 == strcmp (mode_arg->sval[0], "detail")) ||
      (0 == strcmp (mode_arg->sval[0], "d")))
    {
      mode = MODE_DETAIL;
    }
  else if ((0 == strcmp (mode_arg->sval[0], "pretty")) ||
	   (0 == strcmp (mode_arg->sval[0], "p")))
    {
      mode = MODE_DETAIL;
    }
  else if ((0 == strcmp (mode_arg->sval[0], "access")) ||
	   (0 == strcmp (mode_arg->sval[0], "a")))
    {
      mode = MODE_DETAIL;
    }
  else if ((0 == strcmp (mode_arg->sval[0], "width")) ||
	   (0 == strcmp (mode_arg->sval[0], "w")))
    {
      mode = MODE_DETAIL;
    }
  else
    {
      fprintf (stderr, "Impossible mode: %s\n", mode_arg->sval[0]);
    }
 
  /* Group bits */
  group_bits = group->ival[0];
 
  /* Start and end addresses */
  start_addr = from->ival[0];
  end_addr = to->ival[0];
 
  /* Get the profile */
  fprof = fopen (prof_file->filename[0], "rm");
 
  if (!fprof)
    {
      fprintf (stderr, "Cannot open profile file: %s\n",
	       prof_file->filename[0]);
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  /* Finished with the args */
  arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
 
  init ();
  read_file (fprof, mode);
  fclose (fprof);
  printout (mode);
  return 0;
 
}	/* main_mprofiler () */