1 /* This file is part of the program psim.
3 Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <http://www.gnu.org/licenses/>.
34 #ifdef HAVE_SYS_TYPES_H
35 #include <sys/types.h>
38 #ifdef HAVE_SYS_TIMES_H
39 #include <sys/times.h>
42 #ifdef HAVE_SYS_TIME_H
46 #ifdef HAVE_SYS_RESOURCE_H
47 #include <sys/resource.h>
51 #define MAX_BYTE_READWRITE 9
52 #define MAX_SHIFT_READWRITE 3
55 count_type issue_count
[nr_itable_entries
];
56 count_type read_count
;
57 count_type read_byte_count
[MAX_BYTE_READWRITE
];
58 count_type write_count
;
59 count_type write_byte_count
[MAX_BYTE_READWRITE
];
60 count_type unaligned_read_count
;
61 count_type unaligned_write_count
;
62 count_type event_count
[nr_mon_events
];
67 cpu_mon cpu_monitor
[MAX_NR_PROCESSORS
];
75 mon
*monitor
= ZALLOC(mon
);
85 if (cpu_nr
< 0 || cpu_nr
>= MAX_NR_PROCESSORS
)
86 error("mon_cpu() - invalid cpu number\n");
87 return &monitor
->cpu_monitor
[cpu_nr
];
93 mon_init(mon
*monitor
,
96 memset(monitor
, 0, sizeof(*monitor
));
97 monitor
->nr_cpus
= nr_cpus
;
103 mon_issue(itable_index index
,
107 cpu_mon
*monitor
= cpu_monitor(processor
);
108 ASSERT(index
<= nr_itable_entries
);
109 monitor
->issue_count
[index
] += 1;
115 mon_read(unsigned_word ea
,
121 cpu_mon
*monitor
= cpu_monitor(processor
);
122 monitor
->read_count
+= 1;
123 monitor
->read_byte_count
[nr_bytes
] += 1;
124 if ((nr_bytes
- 1) & ea
)
125 monitor
->unaligned_read_count
+= 1;
131 mon_write(unsigned_word ea
,
137 cpu_mon
*monitor
= cpu_monitor(processor
);
138 monitor
->write_count
+= 1;
139 monitor
->write_byte_count
[nr_bytes
] += 1;
140 if ((nr_bytes
- 1) & ea
)
141 monitor
->unaligned_write_count
+= 1;
146 mon_event(mon_events event
,
150 cpu_mon
*monitor
= cpu_monitor(processor
);
151 ASSERT(event
< nr_mon_events
);
152 monitor
->event_count
[event
] += 1;
157 mon_get_number_of_insns(mon
*monitor
,
161 unsigned total_insns
= 0;
162 ASSERT(cpu_nr
>= 0 && cpu_nr
< monitor
->nr_cpus
);
163 for (index
= 0; index
< nr_itable_entries
; index
++)
164 total_insns
+= monitor
->cpu_monitor
[cpu_nr
].issue_count
[index
];
170 mon_sort_instruction_names(const void *ptr_a
, const void *ptr_b
)
172 itable_index a
= *(const itable_index
*)ptr_a
;
173 itable_index b
= *(const itable_index
*)ptr_b
;
175 return strcmp (itable
[a
].name
, itable
[b
].name
);
180 mon_add_commas(char *buf
,
185 char *endbuf
= buf
+ sizeof_buf
- 1;
195 *--endbuf
= (value
% 10) + '0';
196 } while ((value
/= 10) != 0);
198 ASSERT(endbuf
>= buf
);
205 mon_print_info(psim
*system
,
217 int len_sub_num
[MAX_BYTE_READWRITE
];
220 long total_insns
= 0;
221 long cpu_insns_second
= 0;
222 long total_sim_cycles
= 0;
223 long sim_cycles_second
= 0;
224 double cpu_time
= 0.0;
226 for (i
= 0; i
< MAX_BYTE_READWRITE
; i
++)
229 for (cpu_nr
= 0; cpu_nr
< monitor
->nr_cpus
; cpu_nr
++) {
230 count_type num_insns
= mon_get_number_of_insns(monitor
, cpu_nr
);
232 total_insns
+= num_insns
;
233 len
= strlen (mon_add_commas(buffer
, sizeof(buffer
), num_insns
));
237 for (i
= 0; i
<= MAX_SHIFT_READWRITE
; i
++) {
239 len
= strlen (mon_add_commas(buffer
, sizeof(buffer
),
240 monitor
->cpu_monitor
[cpu_nr
].read_byte_count
[size
]));
241 if (len_sub_num
[size
] < len
)
242 len_sub_num
[size
] = len
;
244 len
= strlen (mon_add_commas(buffer
, sizeof(buffer
),
245 monitor
->cpu_monitor
[cpu_nr
].write_byte_count
[size
]));
246 if (len_sub_num
[size
] < len
)
247 len_sub_num
[size
] = len
;
251 sprintf (buffer
, "%d", (int)monitor
->nr_cpus
+ 1);
252 len_cpu
= strlen (buffer
);
254 #ifdef HAVE_GETRUSAGE
256 struct rusage mytime
;
257 if (getrusage (RUSAGE_SELF
, &mytime
) == 0
258 && (mytime
.ru_utime
.tv_sec
> 0 || mytime
.ru_utime
.tv_usec
> 0)) {
260 cpu_time
= (double)mytime
.ru_utime
.tv_sec
+ (((double)mytime
.ru_utime
.tv_usec
) / 1000000.0);
264 total_sim_cycles
= event_queue_time(psim_event_queue(system
)) - 1;
267 cpu_insns_second
= (long)(((double)total_insns
/ cpu_time
) + 0.5);
268 if (total_sim_cycles
) {
269 sim_cycles_second
= (long)(((double)total_sim_cycles
/ cpu_time
) + 0.5);
274 for (cpu_nr
= 0; cpu_nr
< monitor
->nr_cpus
; cpu_nr
++) {
277 itable_index sort_insns
[nr_itable_entries
];
278 int nr_sort_insns
= 0;
283 printf_filtered ("\n");
285 for (index
= 0; index
< nr_itable_entries
; index
++) {
286 if (monitor
->cpu_monitor
[cpu_nr
].issue_count
[index
]) {
287 sort_insns
[nr_sort_insns
++] = index
;
291 qsort((void *)sort_insns
, nr_sort_insns
, sizeof(sort_insns
[0]), mon_sort_instruction_names
);
293 for (index2
= 0; index2
< nr_sort_insns
; index2
++) {
294 index
= sort_insns
[index2
];
295 printf_filtered("CPU #%*d executed %*s %s instruction%s.\n",
297 len_num
, mon_add_commas(buffer
,
299 monitor
->cpu_monitor
[cpu_nr
].issue_count
[index
]),
301 (monitor
->cpu_monitor
[cpu_nr
].issue_count
[index
] == 1) ? "" : "s");
304 printf_filtered ("\n");
307 if (CURRENT_MODEL_ISSUE
> 0)
309 model_data
*model_ptr
= cpu_model(psim_cpu(system
, cpu_nr
));
310 model_print
*ptr
= model_mon_info(model_ptr
);
311 model_print
*orig_ptr
= ptr
;
315 printf_filtered("CPU #%*d executed %*s %s%s.\n",
317 len_num
, mon_add_commas(buffer
,
322 ? ptr
->suffix_singular
323 : ptr
->suffix_plural
));
328 model_mon_info_free(model_ptr
, orig_ptr
);
331 if (monitor
->cpu_monitor
[cpu_nr
].read_count
)
332 printf_filtered ("CPU #%*d executed %*s read%s (%*s 1-byte, %*s 2-byte, %*s 4-byte, %*s 8-byte).\n",
334 len_num
, mon_add_commas(buffer
,
336 monitor
->cpu_monitor
[cpu_nr
].read_count
),
337 (monitor
->cpu_monitor
[cpu_nr
].read_count
== 1) ? "" : "s",
338 len_sub_num
[1], mon_add_commas(buffer1
,
340 monitor
->cpu_monitor
[cpu_nr
].read_byte_count
[1]),
341 len_sub_num
[2], mon_add_commas(buffer2
,
343 monitor
->cpu_monitor
[cpu_nr
].read_byte_count
[2]),
344 len_sub_num
[4], mon_add_commas(buffer4
,
346 monitor
->cpu_monitor
[cpu_nr
].read_byte_count
[4]),
347 len_sub_num
[8], mon_add_commas(buffer8
,
349 monitor
->cpu_monitor
[cpu_nr
].read_byte_count
[8]));
351 if (monitor
->cpu_monitor
[cpu_nr
].write_count
)
352 printf_filtered ("CPU #%*d executed %*s write%s (%*s 1-byte, %*s 2-byte, %*s 4-byte, %*s 8-byte).\n",
354 len_num
, mon_add_commas(buffer
,
356 monitor
->cpu_monitor
[cpu_nr
].write_count
),
357 (monitor
->cpu_monitor
[cpu_nr
].write_count
== 1) ? "" : "s",
358 len_sub_num
[1], mon_add_commas(buffer1
,
360 monitor
->cpu_monitor
[cpu_nr
].write_byte_count
[1]),
361 len_sub_num
[2], mon_add_commas(buffer2
,
363 monitor
->cpu_monitor
[cpu_nr
].write_byte_count
[2]),
364 len_sub_num
[4], mon_add_commas(buffer4
,
366 monitor
->cpu_monitor
[cpu_nr
].write_byte_count
[4]),
367 len_sub_num
[8], mon_add_commas(buffer8
,
369 monitor
->cpu_monitor
[cpu_nr
].write_byte_count
[8]));
371 if (monitor
->cpu_monitor
[cpu_nr
].unaligned_read_count
)
372 printf_filtered ("CPU #%*d executed %*s unaligned read%s.\n",
374 len_num
, mon_add_commas(buffer
,
376 monitor
->cpu_monitor
[cpu_nr
].unaligned_read_count
),
377 (monitor
->cpu_monitor
[cpu_nr
].unaligned_read_count
== 1) ? "" : "s");
379 if (monitor
->cpu_monitor
[cpu_nr
].unaligned_write_count
)
380 printf_filtered ("CPU #%*d executed %*s unaligned write%s.\n",
382 len_num
, mon_add_commas(buffer
,
384 monitor
->cpu_monitor
[cpu_nr
].unaligned_write_count
),
385 (monitor
->cpu_monitor
[cpu_nr
].unaligned_write_count
== 1) ? "" : "s");
387 if (monitor
->cpu_monitor
[cpu_nr
].event_count
[mon_event_icache_miss
])
388 printf_filtered ("CPU #%*d executed %*s icache miss%s.\n",
390 len_num
, mon_add_commas(buffer
,
392 monitor
->cpu_monitor
[cpu_nr
].event_count
[mon_event_icache_miss
]),
393 (monitor
->cpu_monitor
[cpu_nr
].event_count
[mon_event_icache_miss
] == 1) ? "" : "es");
396 long nr_insns
= mon_get_number_of_insns(monitor
, cpu_nr
);
398 printf_filtered("CPU #%*d executed %*s instructions in total.\n",
400 len_num
, mon_add_commas(buffer
,
406 if (total_insns
> 0) {
407 if (monitor
->nr_cpus
> 1)
408 printf_filtered("\nAll CPUs executed %s instructions in total.\n",
409 mon_add_commas(buffer
, sizeof(buffer
), total_insns
));
411 else if (total_sim_cycles
> 0) {
412 printf_filtered("\nSimulator performed %s simulation cycles.\n",
413 mon_add_commas(buffer
, sizeof(buffer
), total_sim_cycles
));
416 if (cpu_insns_second
)
417 printf_filtered ("%sSimulator speed was %s instructions/second.\n",
418 (monitor
->nr_cpus
> 1) ? "" : "\n",
419 mon_add_commas(buffer
, sizeof(buffer
), cpu_insns_second
));
420 else if (sim_cycles_second
)
421 printf_filtered ("Simulator speed was %s simulation cycles/second\n",
422 mon_add_commas(buffer
, sizeof(buffer
), sim_cycles_second
));
423 else if (cpu_time
> 0.0)
424 printf_filtered ("%sSimulator executed for %.2f seconds\n",
425 (monitor
->nr_cpus
> 1) ? "" : "\n", cpu_time
);