/* This file is part of the program psim.
- Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
+ 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
+ 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,
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.
+ along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _MON_C_
#define _MON_C_
-#ifndef STATIC_INLINE_MON
-#define STATIC_INLINE_MON STATIC_INLINE
-#endif
-
#include "basics.h"
#include "cpu.h"
#include "mon.h"
#include <stdlib.h>
#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
#ifdef HAVE_TIME_H
#include <time.h>
#endif
#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];
};
-INLINE_MON mon *
+INLINE_MON\
+(mon *)
mon_create(void)
{
mon *monitor = ZALLOC(mon);
}
-INLINE_MON cpu_mon *
+INLINE_MON\
+(cpu_mon *)
mon_cpu(mon *monitor,
int cpu_nr)
{
}
-INLINE_MON void
+INLINE_MON\
+(void)
mon_init(mon *monitor,
int nr_cpus)
{
}
-INLINE_MON void
+INLINE_MON\
+(void)
mon_issue(itable_index index,
cpu *processor,
unsigned_word cia)
}
-INLINE_MON void
+INLINE_MON\
+(void)
mon_read(unsigned_word ea,
unsigned_word ra,
unsigned nr_bytes,
{
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
+INLINE_MON\
+(void)
mon_write(unsigned_word ea,
unsigned_word ra,
unsigned nr_bytes,
{
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
+INLINE_MON\
+(void)
mon_event(mon_events event,
cpu *processor,
unsigned_word cia)
{
cpu_mon *monitor = cpu_monitor(processor);
- ASSERT(event >= 0 && event < nr_mon_events);
+ ASSERT(event < nr_mon_events);
monitor->event_count[event] += 1;
}
-STATIC_INLINE_MON count_type
-mon_get_number_of_insns(cpu_mon *monitor)
+INLINE_MON\
+(unsigned)
+mon_get_number_of_insns(mon *monitor,
+ int cpu_nr)
{
itable_index index;
- count_type total_insns = 0;
+ unsigned total_insns = 0;
+ ASSERT(cpu_nr >= 0 && cpu_nr < monitor->nr_cpus);
for (index = 0; index < nr_itable_entries; index++)
- total_insns += monitor->issue_count[index];
+ total_insns += monitor->cpu_monitor[cpu_nr].issue_count[index];
return total_insns;
}
-static int
+STATIC_INLINE_MON\
+(int)
mon_sort_instruction_names(const void *ptr_a, const void *ptr_b)
{
itable_index a = *(const itable_index *)ptr_a;
return strcmp (itable[a].name, itable[b].name);
}
-STATIC_INLINE_MON char *
+STATIC_INLINE_MON\
+(char *)
mon_add_commas(char *buf,
int sizeof_buf,
count_type value)
}
-INLINE_MON void
+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_monitor[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
- if (total_insns && verbose > 1)
- {
- 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);
- cpu_insns_second = (long)(((double)total_insns / cpu_time) + 0.5);
- }
+ {
+ 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
printf_filtered ("\n");
}
- if (CURRENT_MODEL)
+ if (CURRENT_MODEL_ISSUE > 0)
{
model_data *model_ptr = cpu_model(psim_cpu(system, cpu_nr));
model_print *ptr = model_mon_info(model_ptr);
}
if (monitor->cpu_monitor[cpu_nr].read_count)
- printf_filtered ("CPU #%*d executed %*s data read%s.\n",
+ 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");
+ (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 data write%s.\n",
+ 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");
+ (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 data read%s.\n",
+ 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].read_count),
- (monitor->cpu_monitor[cpu_nr].read_count == 1) ? "" : "s");
+ 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 data write%s.\n",
+ 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].write_count),
- (monitor->cpu_monitor[cpu_nr].write_count == 1) ? "" : "s");
+ 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",
monitor->cpu_monitor[cpu_nr].event_count[mon_event_icache_miss]),
(monitor->cpu_monitor[cpu_nr].event_count[mon_event_icache_miss] == 1) ? "" : "es");
- printf_filtered("CPU #%*d executed %*s instructions in total.\n",
- len_cpu, cpu_nr+1,
- len_num, mon_add_commas(buffer,
- sizeof(buffer),
- mon_get_number_of_insns(&monitor->cpu_monitor[cpu_nr])));
-
+ {
+ 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 (monitor->nr_cpus > 1)
- printf_filtered("\nAll CPUs executed %s instructions in total.\n",
- mon_add_commas(buffer, sizeof(buffer), total_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 && verbose <= 1) ? "" : "\n",
+ 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_ */