Subversion Repositories or1k

/*  This file is part of the program psim.

    Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>

    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 2 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, write to the Free Software

    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

    */

#ifndef _MON_C_

#define _MON_C_

#include "basics.h"

#include "cpu.h"

#include "mon.h"

#include <stdio.h>

#ifdef HAVE_STRING_H

#include <string.h>

#else

#ifdef HAVE_STRINGS_H

#include <strings.h>

#endif

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_TIME_H

#include <time.h>

#endif

#ifdef HAVE_SYS_TIMES_H

#include <sys/times.h>

#endif

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE_SYS_RESOURCE_H

#include <sys/resource.h>

int getrusage();

#endif

#define MAX_BYTE_READWRITE 9

#define MAX_SHIFT_READWRITE 3

struct _cpu_mon {

  count_type issue_count[nr_itable_entries];

  count_type read_count;

  count_type read_byte_count[MAX_BYTE_READWRITE];

  count_type write_count;

  count_type write_byte_count[MAX_BYTE_READWRITE];

  count_type unaligned_read_count;

  count_type unaligned_write_count;

  count_type event_count[nr_mon_events];

};

struct _mon {

  int nr_cpus;

  cpu_mon cpu_monitor[MAX_NR_PROCESSORS];

};

INLINE_MON\

(mon *)

mon_create(void)

{

  mon *monitor = ZALLOC(mon);

  return monitor;

}

INLINE_MON\

(cpu_mon *)

mon_cpu(mon *monitor,

        int cpu_nr)

{

  if (cpu_nr < 0 || cpu_nr >= MAX_NR_PROCESSORS)

    error("mon_cpu() - invalid cpu number\n");

  return &monitor->cpu_monitor[cpu_nr];

}

INLINE_MON\

(void)

mon_init(mon *monitor,

         int nr_cpus)

{

  memset(monitor, 0, sizeof(*monitor));

  monitor->nr_cpus = nr_cpus;

}

INLINE_MON\

(void)

mon_issue(itable_index index,

          cpu *processor,

          unsigned_word cia)

{

  cpu_mon *monitor = cpu_monitor(processor);

  ASSERT(index <= nr_itable_entries);

  monitor->issue_count[index] += 1;

}

INLINE_MON\

(void)

mon_read(unsigned_word ea,

         unsigned_word ra,

         unsigned nr_bytes,

         cpu *processor,

         unsigned_word cia)

{

  cpu_mon *monitor = cpu_monitor(processor);

  monitor->read_count += 1;

  monitor->read_byte_count[nr_bytes] += 1;

  if ((nr_bytes - 1) & ea)

    monitor->unaligned_read_count += 1;

}

INLINE_MON\

(void)

mon_write(unsigned_word ea,

          unsigned_word ra,

          unsigned nr_bytes,

          cpu *processor,

          unsigned_word cia)

{

  cpu_mon *monitor = cpu_monitor(processor);

  monitor->write_count += 1;

  monitor->write_byte_count[nr_bytes] += 1;

  if ((nr_bytes - 1) & ea)

    monitor->unaligned_write_count += 1;

}

INLINE_MON\

(void)

mon_event(mon_events event,

          cpu *processor,

          unsigned_word cia)

{

  cpu_mon *monitor = cpu_monitor(processor);

  ASSERT(event < nr_mon_events);

  monitor->event_count[event] += 1;

}

INLINE_MON\

(unsigned)

mon_get_number_of_insns(mon *monitor,

                        int cpu_nr)

{

  itable_index index;

  unsigned total_insns = 0;

  ASSERT(cpu_nr >= 0 && cpu_nr < monitor->nr_cpus);

  for (index = 0; index < nr_itable_entries; index++)

    total_insns += monitor->cpu_monitor[cpu_nr].issue_count[index];

  return total_insns;

}

STATIC_INLINE_MON\

(int)

mon_sort_instruction_names(const void *ptr_a, const void *ptr_b)

{

  itable_index a = *(const itable_index *)ptr_a;

  itable_index b = *(const itable_index *)ptr_b;

  return strcmp (itable[a].name, itable[b].name);

}

STATIC_INLINE_MON\

(char *)

mon_add_commas(char *buf,

               int sizeof_buf,

               count_type value)

{

  int comma = 3;

  char *endbuf = buf + sizeof_buf - 1;

  *--endbuf = '\0';

  do {

    if (comma-- == 0)

      {

        *--endbuf = ',';

        comma = 2;

      }

    *--endbuf = (value % 10) + '0';

  } while ((value /= 10) != 0);

  ASSERT(endbuf >= buf);

  return endbuf;

}

INLINE_MON\

(void)

mon_print_info(psim *system,

               mon *monitor,

               int verbose)

{

  char buffer[20];

  char buffer1[20];

  char buffer2[20];

  char buffer4[20];

  char buffer8[20];

  int cpu_nr;

  int len_cpu;

  int len_num = 0;

  int len_sub_num[MAX_BYTE_READWRITE];

  int len;

  int i;

  long total_insns = 0;

  long cpu_insns_second = 0;

  long total_sim_cycles = 0;

  long sim_cycles_second = 0;

  double cpu_time = 0.0;

  for (i = 0; i < MAX_BYTE_READWRITE; i++)

    len_sub_num[i] = 0;

  for (cpu_nr = 0; cpu_nr < monitor->nr_cpus; cpu_nr++) {

    count_type num_insns = mon_get_number_of_insns(monitor, cpu_nr);

    total_insns += num_insns;

    len = strlen (mon_add_commas(buffer, sizeof(buffer), num_insns));

    if (len_num < len)

      len_num = len;

    for (i = 0; i <= MAX_SHIFT_READWRITE; i++) {

      int size = 1<<i;

      len = strlen (mon_add_commas(buffer, sizeof(buffer),

                                   monitor->cpu_monitor[cpu_nr].read_byte_count[size]));

      if (len_sub_num[size] < len)

        len_sub_num[size] = len;

      len = strlen (mon_add_commas(buffer, sizeof(buffer),

                                   monitor->cpu_monitor[cpu_nr].write_byte_count[size]));

      if (len_sub_num[size] < len)

        len_sub_num[size] = len;

    }

  }

  sprintf (buffer, "%d", (int)monitor->nr_cpus + 1);

  len_cpu = strlen (buffer);

#ifdef HAVE_GETRUSAGE

  {

    struct rusage mytime;

    if (getrusage (RUSAGE_SELF, &mytime) == 0

        && (mytime.ru_utime.tv_sec > 0 || mytime.ru_utime.tv_usec > 0)) {

      cpu_time = (double)mytime.ru_utime.tv_sec + (((double)mytime.ru_utime.tv_usec) / 1000000.0);

    }

  }

  if (WITH_EVENTS)

    total_sim_cycles = event_queue_time(psim_event_queue(system)) - 1;

  if (cpu_time > 0) {

    if (total_insns > 0)

      cpu_insns_second = (long)(((double)total_insns / cpu_time) + 0.5);

    if (total_sim_cycles) {

      sim_cycles_second = (long)(((double)total_sim_cycles / cpu_time) + 0.5);

    }

  }

#endif

  for (cpu_nr = 0; cpu_nr < monitor->nr_cpus; cpu_nr++) {

    if (verbose > 1) {

      itable_index sort_insns[nr_itable_entries];

      int nr_sort_insns = 0;

      itable_index index;

      int index2;

      if (cpu_nr)

        printf_filtered ("\n");

      for (index = 0; index < nr_itable_entries; index++) {

        if (monitor->cpu_monitor[cpu_nr].issue_count[index]) {

          sort_insns[nr_sort_insns++] = index;

        }

      }

      qsort((void *)sort_insns, nr_sort_insns, sizeof(sort_insns[0]), mon_sort_instruction_names);

      for (index2 = 0; index2 < nr_sort_insns; index2++) {

        index = sort_insns[index2];

        printf_filtered("CPU #%*d executed %*s %s instruction%s.\n",

                        len_cpu, cpu_nr+1,

                        len_num, mon_add_commas(buffer,

                                                sizeof(buffer),

                                                monitor->cpu_monitor[cpu_nr].issue_count[index]),

                          itable[index].name,

                          (monitor->cpu_monitor[cpu_nr].issue_count[index] == 1) ? "" : "s");

      }

      printf_filtered ("\n");

    }

    if (CURRENT_MODEL_ISSUE > 0)

      {

        model_data *model_ptr = cpu_model(psim_cpu(system, cpu_nr));

        model_print *ptr = model_mon_info(model_ptr);

        model_print *orig_ptr = ptr;

        while (ptr) {

          if (ptr->count)

            printf_filtered("CPU #%*d executed %*s %s%s.\n",

                            len_cpu, cpu_nr+1,

                            len_num, mon_add_commas(buffer,

                                                    sizeof(buffer),

                                                    ptr->count),

                            ptr->name,

                            ((ptr->count == 1)

                             ? ptr->suffix_singular

                             : ptr->suffix_plural));

          ptr = ptr->next;

        }

        model_mon_info_free(model_ptr, orig_ptr);

      }

    if (monitor->cpu_monitor[cpu_nr].read_count)

      printf_filtered ("CPU #%*d executed %*s read%s  (%*s 1-byte, %*s 2-byte, %*s 4-byte, %*s 8-byte).\n",

                       len_cpu, cpu_nr+1,

                       len_num, mon_add_commas(buffer,

                                               sizeof(buffer),

                                               monitor->cpu_monitor[cpu_nr].read_count),

                       (monitor->cpu_monitor[cpu_nr].read_count == 1) ? "" : "s",

                       len_sub_num[1], mon_add_commas(buffer1,

                                                      sizeof(buffer1),

                                                      monitor->cpu_monitor[cpu_nr].read_byte_count[1]),

                       len_sub_num[2], mon_add_commas(buffer2,

                                                      sizeof(buffer2),

                                                      monitor->cpu_monitor[cpu_nr].read_byte_count[2]),

                       len_sub_num[4], mon_add_commas(buffer4,

                                                      sizeof(buffer4),

                                                      monitor->cpu_monitor[cpu_nr].read_byte_count[4]),

                       len_sub_num[8], mon_add_commas(buffer8,

                                                      sizeof(buffer8),

                                                      monitor->cpu_monitor[cpu_nr].read_byte_count[8]));

    if (monitor->cpu_monitor[cpu_nr].write_count)

      printf_filtered ("CPU #%*d executed %*s write%s (%*s 1-byte, %*s 2-byte, %*s 4-byte, %*s 8-byte).\n",

                       len_cpu, cpu_nr+1,

                       len_num, mon_add_commas(buffer,

                                               sizeof(buffer),

                                               monitor->cpu_monitor[cpu_nr].write_count),

                       (monitor->cpu_monitor[cpu_nr].write_count == 1) ? "" : "s",

                       len_sub_num[1], mon_add_commas(buffer1,

                                                      sizeof(buffer1),

                                                      monitor->cpu_monitor[cpu_nr].write_byte_count[1]),

                       len_sub_num[2], mon_add_commas(buffer2,

                                                      sizeof(buffer2),

                                                      monitor->cpu_monitor[cpu_nr].write_byte_count[2]),

                       len_sub_num[4], mon_add_commas(buffer4,

                                                      sizeof(buffer4),

                                                      monitor->cpu_monitor[cpu_nr].write_byte_count[4]),

                       len_sub_num[8], mon_add_commas(buffer8,

                                                      sizeof(buffer8),

                                                      monitor->cpu_monitor[cpu_nr].write_byte_count[8]));

    if (monitor->cpu_monitor[cpu_nr].unaligned_read_count)

      printf_filtered ("CPU #%*d executed %*s unaligned read%s.\n",

                       len_cpu, cpu_nr+1,

                       len_num, mon_add_commas(buffer,

                                               sizeof(buffer),

                                               monitor->cpu_monitor[cpu_nr].unaligned_read_count),

                       (monitor->cpu_monitor[cpu_nr].unaligned_read_count == 1) ? "" : "s");

    if (monitor->cpu_monitor[cpu_nr].unaligned_write_count)

      printf_filtered ("CPU #%*d executed %*s unaligned write%s.\n",

                       len_cpu, cpu_nr+1,

                       len_num, mon_add_commas(buffer,

                                               sizeof(buffer),

                                               monitor->cpu_monitor[cpu_nr].unaligned_write_count),

                       (monitor->cpu_monitor[cpu_nr].unaligned_write_count == 1) ? "" : "s");

    if (monitor->cpu_monitor[cpu_nr].event_count[mon_event_icache_miss])

      printf_filtered ("CPU #%*d executed %*s icache miss%s.\n",

                       len_cpu, cpu_nr+1,

                       len_num, mon_add_commas(buffer,

                                               sizeof(buffer),

                                               monitor->cpu_monitor[cpu_nr].event_count[mon_event_icache_miss]),

                       (monitor->cpu_monitor[cpu_nr].event_count[mon_event_icache_miss] == 1) ? "" : "es");

    {

      long nr_insns = mon_get_number_of_insns(monitor, cpu_nr);

      if (nr_insns > 0)

        printf_filtered("CPU #%*d executed %*s instructions in total.\n",

                        len_cpu, cpu_nr+1,

                        len_num, mon_add_commas(buffer,

                                                sizeof(buffer),

                                                nr_insns));

    }

  }

  if (total_insns > 0) {

    if (monitor->nr_cpus > 1)

      printf_filtered("\nAll CPUs executed %s instructions in total.\n",

                      mon_add_commas(buffer, sizeof(buffer), total_insns));

  }

  else if (total_sim_cycles > 0) {

    printf_filtered("\nSimulator performed %s simulation cycles.\n",

                    mon_add_commas(buffer, sizeof(buffer), total_sim_cycles));

  }

  if (cpu_insns_second)

    printf_filtered ("%sSimulator speed was %s instructions/second.\n",

                     (monitor->nr_cpus > 1) ? "" : "\n",

                     mon_add_commas(buffer, sizeof(buffer), cpu_insns_second));

  else if (sim_cycles_second)

    printf_filtered ("Simulator speed was %s simulation cycles/second\n",

                     mon_add_commas(buffer, sizeof(buffer), sim_cycles_second));

  else if (cpu_time > 0.0)

    printf_filtered ("%sSimulator executed for %.2f seconds\n",

                     (monitor->nr_cpus > 1) ? "" : "\n", cpu_time);

}

#endif /* _MON_C_ */