| /* Simulator cache routines for CGEN simulators (and maybe others). | |
| Copyright (C) 1996, 1997, 1998, 2007, 2008 Free Software Foundation, Inc. | |
| Contributed by Cygnus Support. | |
| This file is part of GDB, the GNU debugger. | |
| 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/>. */ | |
| #define SCACHE_DEFINE_INLINE | |
| #include "sim-main.h" | |
| #ifdef HAVE_STDLIB_H | |
| #include <stdlib.h> | |
| #endif | |
| #include "libiberty.h" | |
| #include "sim-options.h" | |
| #include "sim-io.h" | |
| #define MAX(a,b) ((a) > (b) ? (a) : (b)) | |
| /* Unused address. */ | |
| #define UNUSED_ADDR 0xffffffff | |
| /* Scache configuration parameters. | |
| ??? Experiments to determine reasonable values is wip. | |
| These are just guesses. */ | |
| /* Default number of scache elements. | |
| The size of an element is typically 32-64 bytes, so the size of the | |
| default scache will be between 512K and 1M bytes. */ | |
| #ifdef CONFIG_SIM_CACHE_SIZE | |
| #define SCACHE_DEFAULT_CACHE_SIZE CONFIG_SIM_CACHE_SIZE | |
| #else | |
| #define SCACHE_DEFAULT_CACHE_SIZE 16384 | |
| #endif | |
| /* Minimum cache size. | |
| The m32r port assumes a cache size of at least 2 so it can decode both 16 | |
| bit insns. When compiling we need an extra for the chain entry. And this | |
| must be a multiple of 2. Hence 4 is the minimum (though, for those with | |
| featuritis or itchy pedantic bits, we could make this conditional on | |
| WITH_SCACHE_PBB). */ | |
| #define MIN_SCACHE_SIZE 4 | |
| /* Ratio of size of text section to size of scache. | |
| When compiling, we don't want to flush the scache more than we have to | |
| but we also don't want it to be exorbitantly(sp?) large. So we pick a high | |
| default value, then reduce it by the size of the program being simulated, | |
| but we don't override any value specified on the command line. | |
| If not specified on the command line, the size to use is computed as | |
| max (MIN_SCACHE_SIZE, | |
| min (DEFAULT_SCACHE_SIZE, | |
| text_size / (base_insn_size * INSN_SCACHE_RATIO))). */ | |
| /* ??? Interesting idea but not currently used. */ | |
| #define INSN_SCACHE_RATIO 4 | |
| /* Default maximum insn chain length. | |
| The only reason for a maximum is so we can place a maximum size on the | |
| profiling table. Chain lengths are determined by cti's. | |
| 32 is a more reasonable number, but when profiling, the before/after | |
| handlers take up that much more space. The scache is filled from front to | |
| back so all this determines is when the scache needs to be flushed. */ | |
| #define MAX_CHAIN_LENGTH 64 | |
| /* Default maximum hash list length. */ | |
| #define MAX_HASH_CHAIN_LENGTH 4 | |
| /* Minimum hash table size. */ | |
| #define MIN_HASH_CHAINS 32 | |
| /* Ratio of number of scache elements to number of hash lists. | |
| Since the user can only specify the size of the scache, we compute the | |
| size of the hash table as | |
| max (MIN_HASH_CHAINS, scache_size / SCACHE_HASH_RATIO). */ | |
| #define SCACHE_HASH_RATIO 8 | |
| /* Hash a PC value. | |
| FIXME: May wish to make the hashing architecture specific. | |
| FIXME: revisit */ | |
| #define HASH_PC(pc) (((pc) >> 2) + ((pc) >> 5)) | |
| static MODULE_INIT_FN scache_init; | |
| static MODULE_UNINSTALL_FN scache_uninstall; | |
| static DECLARE_OPTION_HANDLER (scache_option_handler); | |
| #define OPTION_PROFILE_SCACHE (OPTION_START + 0) | |
| static const OPTION scache_options[] = { | |
| { {"scache-size", optional_argument, NULL, 'c'}, | |
| 'c', "[SIZE]", "Specify size of simulator execution cache", | |
| scache_option_handler }, | |
| #if WITH_SCACHE_PBB | |
| /* ??? It might be nice to allow the user to specify the size of the hash | |
| table, the maximum hash list length, and the maximum chain length, but | |
| for now that might be more akin to featuritis. */ | |
| #endif | |
| { {"profile-scache", optional_argument, NULL, OPTION_PROFILE_SCACHE}, | |
| '\0', "on|off", "Perform simulator execution cache profiling", | |
| scache_option_handler }, | |
| { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL } | |
| }; | |
| static SIM_RC | |
| scache_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt, | |
| char *arg, int is_command) | |
| { | |
| switch (opt) | |
| { | |
| case 'c' : | |
| if (WITH_SCACHE) | |
| { | |
| if (arg != NULL) | |
| { | |
| int n = strtol (arg, NULL, 0); | |
| if (n < MIN_SCACHE_SIZE) | |
| { | |
| sim_io_eprintf (sd, "invalid scache size `%d', must be at least 4", n); | |
| return SIM_RC_FAIL; | |
| } | |
| /* Ensure it's a multiple of 2. */ | |
| if ((n & (n - 1)) != 0) | |
| { | |
| sim_io_eprintf (sd, "scache size `%d' not a multiple of 2\n", n); | |
| { | |
| /* round up to nearest multiple of 2 */ | |
| int i; | |
| for (i = 1; i < n; i <<= 1) | |
| continue; | |
| n = i; | |
| } | |
| sim_io_eprintf (sd, "rounding scache size up to %d\n", n); | |
| } | |
| if (cpu == NULL) | |
| STATE_SCACHE_SIZE (sd) = n; | |
| else | |
| CPU_SCACHE_SIZE (cpu) = n; | |
| } | |
| else | |
| { | |
| if (cpu == NULL) | |
| STATE_SCACHE_SIZE (sd) = SCACHE_DEFAULT_CACHE_SIZE; | |
| else | |
| CPU_SCACHE_SIZE (cpu) = SCACHE_DEFAULT_CACHE_SIZE; | |
| } | |
| } | |
| else | |
| sim_io_eprintf (sd, "Simulator execution cache not enabled, `--scache-size' ignored\n"); | |
| break; | |
| case OPTION_PROFILE_SCACHE : | |
| if (WITH_SCACHE && WITH_PROFILE_SCACHE_P) | |
| { | |
| /* FIXME: handle cpu != NULL. */ | |
| return sim_profile_set_option (sd, "-scache", PROFILE_SCACHE_IDX, | |
| arg); | |
| } | |
| else | |
| sim_io_eprintf (sd, "Simulator cache profiling not compiled in, `--profile-scache' ignored\n"); | |
| break; | |
| } | |
| return SIM_RC_OK; | |
| } | |
| SIM_RC | |
| scache_install (SIM_DESC sd) | |
| { | |
| sim_add_option_table (sd, NULL, scache_options); | |
| sim_module_add_init_fn (sd, scache_init); | |
| sim_module_add_uninstall_fn (sd, scache_uninstall); | |
| /* This is the default, it may be overridden on the command line. */ | |
| STATE_SCACHE_SIZE (sd) = WITH_SCACHE; | |
| return SIM_RC_OK; | |
| } | |
| static SIM_RC | |
| scache_init (SIM_DESC sd) | |
| { | |
| int c; | |
| for (c = 0; c < MAX_NR_PROCESSORS; ++c) | |
| { | |
| SIM_CPU *cpu = STATE_CPU (sd, c); | |
| int elm_size = IMP_PROPS_SCACHE_ELM_SIZE (MACH_IMP_PROPS (CPU_MACH (cpu))); | |
| /* elm_size is 0 if the cpu doesn't not have scache support */ | |
| if (elm_size == 0) | |
| { | |
| CPU_SCACHE_SIZE (cpu) = 0; | |
| CPU_SCACHE_CACHE (cpu) = NULL; | |
| } | |
| else | |
| { | |
| if (CPU_SCACHE_SIZE (cpu) == 0) | |
| CPU_SCACHE_SIZE (cpu) = STATE_SCACHE_SIZE (sd); | |
| CPU_SCACHE_CACHE (cpu) = | |
| (SCACHE *) xmalloc (CPU_SCACHE_SIZE (cpu) * elm_size); | |
| #if WITH_SCACHE_PBB | |
| CPU_SCACHE_MAX_CHAIN_LENGTH (cpu) = MAX_CHAIN_LENGTH; | |
| CPU_SCACHE_NUM_HASH_CHAIN_ENTRIES (cpu) = MAX_HASH_CHAIN_LENGTH; | |
| CPU_SCACHE_NUM_HASH_CHAINS (cpu) = MAX (MIN_HASH_CHAINS, | |
| CPU_SCACHE_SIZE (cpu) | |
| / SCACHE_HASH_RATIO); | |
| CPU_SCACHE_HASH_TABLE (cpu) = | |
| (SCACHE_MAP *) xmalloc (CPU_SCACHE_NUM_HASH_CHAINS (cpu) | |
| * CPU_SCACHE_NUM_HASH_CHAIN_ENTRIES (cpu) | |
| * sizeof (SCACHE_MAP)); | |
| CPU_SCACHE_PBB_BEGIN (cpu) = (SCACHE *) zalloc (elm_size); | |
| CPU_SCACHE_CHAIN_LENGTHS (cpu) = | |
| (unsigned long *) zalloc ((CPU_SCACHE_MAX_CHAIN_LENGTH (cpu) + 1) | |
| * sizeof (long)); | |
| #endif | |
| } | |
| } | |
| scache_flush (sd); | |
| return SIM_RC_OK; | |
| } | |
| static void | |
| scache_uninstall (SIM_DESC sd) | |
| { | |
| int c; | |
| for (c = 0; c < MAX_NR_PROCESSORS; ++c) | |
| { | |
| SIM_CPU *cpu = STATE_CPU (sd, c); | |
| if (CPU_SCACHE_CACHE (cpu) != NULL) | |
| free (CPU_SCACHE_CACHE (cpu)); | |
| #if WITH_SCACHE_PBB | |
| if (CPU_SCACHE_HASH_TABLE (cpu) != NULL) | |
| free (CPU_SCACHE_HASH_TABLE (cpu)); | |
| if (CPU_SCACHE_PBB_BEGIN (cpu) != NULL) | |
| free (CPU_SCACHE_PBB_BEGIN (cpu)); | |
| if (CPU_SCACHE_CHAIN_LENGTHS (cpu) != NULL) | |
| free (CPU_SCACHE_CHAIN_LENGTHS (cpu)); | |
| #endif | |
| } | |
| } | |
| void | |
| scache_flush (SIM_DESC sd) | |
| { | |
| int c; | |
| for (c = 0; c < MAX_NR_PROCESSORS; ++c) | |
| { | |
| SIM_CPU *cpu = STATE_CPU (sd, c); | |
| scache_flush_cpu (cpu); | |
| } | |
| } | |
| void | |
| scache_flush_cpu (SIM_CPU *cpu) | |
| { | |
| int i,n; | |
| /* Don't bother if cache not in use. */ | |
| if (CPU_SCACHE_SIZE (cpu) == 0) | |
| return; | |
| #if WITH_SCACHE_PBB | |
| /* It's important that this be reasonably fast as this can be done when | |
| the simulation is running. */ | |
| CPU_SCACHE_NEXT_FREE (cpu) = CPU_SCACHE_CACHE (cpu); | |
| n = CPU_SCACHE_NUM_HASH_CHAINS (cpu) * CPU_SCACHE_NUM_HASH_CHAIN_ENTRIES (cpu); | |
| /* ??? Might be faster to just set the first entry, then update the | |
| "last entry" marker during allocation. */ | |
| for (i = 0; i < n; ++i) | |
| CPU_SCACHE_HASH_TABLE (cpu) [i] . pc = UNUSED_ADDR; | |
| #else | |
| { | |
| int elm_size = IMP_PROPS_SCACHE_ELM_SIZE (MACH_IMP_PROPS (CPU_MACH (cpu))); | |
| SCACHE *sc; | |
| /* Technically, this may not be necessary, but it helps debugging. */ | |
| memset (CPU_SCACHE_CACHE (cpu), 0, | |
| CPU_SCACHE_SIZE (cpu) * elm_size); | |
| for (i = 0, sc = CPU_SCACHE_CACHE (cpu); i < CPU_SCACHE_SIZE (cpu); | |
| ++i, sc = (SCACHE *) ((char *) sc + elm_size)) | |
| { | |
| sc->argbuf.addr = UNUSED_ADDR; | |
| } | |
| } | |
| #endif | |
| } | |
| #if WITH_SCACHE_PBB | |
| /* Look up PC in the hash table of scache entry points. | |
| Returns the entry or NULL if not found. */ | |
| SCACHE * | |
| scache_lookup (SIM_CPU *cpu, IADDR pc) | |
| { | |
| /* FIXME: hash computation is wrong, doesn't take into account | |
| NUM_HASH_CHAIN_ENTRIES. A lot of the hash table will be unused! */ | |
| unsigned int slot = HASH_PC (pc) & (CPU_SCACHE_NUM_HASH_CHAINS (cpu) - 1); | |
| int i, max_i = CPU_SCACHE_NUM_HASH_CHAIN_ENTRIES (cpu); | |
| SCACHE_MAP *scm; | |
| /* We don't update hit/miss statistics as this is only used when recording | |
| branch target addresses. */ | |
| scm = & CPU_SCACHE_HASH_TABLE (cpu) [slot]; | |
| for (i = 0; i < max_i && scm->pc != UNUSED_ADDR; ++i, ++scm) | |
| { | |
| if (scm->pc == pc) | |
| return scm->sc; | |
| } | |
| return 0; | |
| } | |
| /* Look up PC and if not found create an entry for it. | |
| If found the result is a pointer to the SCACHE entry. | |
| If not found the result is NULL, and the address of a buffer of at least | |
| N entries is stored in BUFP. | |
| It's done this way so the caller can still distinguish found/not-found. | |
| If the table is full, it is emptied to make room. | |
| If the maximum length of a hash list is reached a random entry is thrown out | |
| to make room. | |
| ??? One might want to try to make this smarter, but let's see some | |
| measurable benefit first. */ | |
| SCACHE * | |
| scache_lookup_or_alloc (SIM_CPU *cpu, IADDR pc, int n, SCACHE **bufp) | |
| { | |
| /* FIXME: hash computation is wrong, doesn't take into account | |
| NUM_HASH_CHAIN_ENTRIES. A lot of the hash table will be unused! */ | |
| unsigned int slot = HASH_PC (pc) & (CPU_SCACHE_NUM_HASH_CHAINS (cpu) - 1); | |
| int i, max_i = CPU_SCACHE_NUM_HASH_CHAIN_ENTRIES (cpu); | |
| SCACHE_MAP *scm; | |
| SCACHE *sc; | |
| scm = & CPU_SCACHE_HASH_TABLE (cpu) [slot]; | |
| for (i = 0; i < max_i && scm->pc != UNUSED_ADDR; ++i, ++scm) | |
| { | |
| if (scm->pc == pc) | |
| { | |
| PROFILE_COUNT_SCACHE_HIT (cpu); | |
| return scm->sc; | |
| } | |
| } | |
| PROFILE_COUNT_SCACHE_MISS (cpu); | |
| /* The address we want isn't cached. Bummer. | |
| If the hash chain we have for this address is full, throw out an entry | |
| to make room. */ | |
| if (i == max_i) | |
| { | |
| /* Rather than do something sophisticated like LRU, we just throw out | |
| a semi-random entry. Let someone else have the joy of saying how | |
| wrong this is. NEXT_FREE is the entry to throw out and cycles | |
| through all possibilities. */ | |
| static int next_free = 0; | |
| scm = & CPU_SCACHE_HASH_TABLE (cpu) [slot]; | |
| /* FIXME: This seems rather clumsy. */ | |
| for (i = 0; i < next_free; ++i, ++scm) | |
| continue; | |
| ++next_free; | |
| if (next_free == CPU_SCACHE_NUM_HASH_CHAIN_ENTRIES (cpu)) | |
| next_free = 0; | |
| } | |
| /* At this point SCM points to the hash table entry to use. | |
| Now make sure there's room in the cache. */ | |
| /* FIXME: Kinda weird to use a next_free adjusted scm when cache is | |
| flushed. */ | |
| { | |
| int elm_size = IMP_PROPS_SCACHE_ELM_SIZE (MACH_IMP_PROPS (CPU_MACH (cpu))); | |
| int elms_used = (((char *) CPU_SCACHE_NEXT_FREE (cpu) | |
| - (char *) CPU_SCACHE_CACHE (cpu)) | |
| / elm_size); | |
| int elms_left = CPU_SCACHE_SIZE (cpu) - elms_used; | |
| if (elms_left < n) | |
| { | |
| PROFILE_COUNT_SCACHE_FULL_FLUSH (cpu); | |
| scache_flush_cpu (cpu); | |
| } | |
| } | |
| sc = CPU_SCACHE_NEXT_FREE (cpu); | |
| scm->pc = pc; | |
| scm->sc = sc; | |
| *bufp = sc; | |
| return NULL; | |
| } | |
| #endif /* WITH_SCACHE_PBB */ | |
| /* Print cache access statics for CPU. */ | |
| void | |
| scache_print_profile (SIM_CPU *cpu, int verbose) | |
| { | |
| SIM_DESC sd = CPU_STATE (cpu); | |
| unsigned long hits = CPU_SCACHE_HITS (cpu); | |
| unsigned long misses = CPU_SCACHE_MISSES (cpu); | |
| char buf[20]; | |
| unsigned long max_val; | |
| unsigned long *lengths; | |
| int i; | |
| if (CPU_SCACHE_SIZE (cpu) == 0) | |
| return; | |
| sim_io_printf (sd, "Simulator Cache Statistics\n\n"); | |
| /* One could use PROFILE_LABEL_WIDTH here. I chose not to. */ | |
| sim_io_printf (sd, " Cache size: %s\n", | |
| sim_add_commas (buf, sizeof (buf), CPU_SCACHE_SIZE (cpu))); | |
| sim_io_printf (sd, " Hits: %s\n", | |
| sim_add_commas (buf, sizeof (buf), hits)); | |
| sim_io_printf (sd, " Misses: %s\n", | |
| sim_add_commas (buf, sizeof (buf), misses)); | |
| if (hits + misses != 0) | |
| sim_io_printf (sd, " Hit rate: %.2f%%\n", | |
| ((double) hits / ((double) hits + (double) misses)) * 100); | |
| #if WITH_SCACHE_PBB | |
| sim_io_printf (sd, "\n"); | |
| sim_io_printf (sd, " Hash table size: %s\n", | |
| sim_add_commas (buf, sizeof (buf), CPU_SCACHE_NUM_HASH_CHAINS (cpu))); | |
| sim_io_printf (sd, " Max hash list length: %s\n", | |
| sim_add_commas (buf, sizeof (buf), CPU_SCACHE_NUM_HASH_CHAIN_ENTRIES (cpu))); | |
| sim_io_printf (sd, " Max insn chain length: %s\n", | |
| sim_add_commas (buf, sizeof (buf), CPU_SCACHE_MAX_CHAIN_LENGTH (cpu))); | |
| sim_io_printf (sd, " Cache full flushes: %s\n", | |
| sim_add_commas (buf, sizeof (buf), CPU_SCACHE_FULL_FLUSHES (cpu))); | |
| sim_io_printf (sd, "\n"); | |
| if (verbose) | |
| { | |
| sim_io_printf (sd, " Insn chain lengths:\n\n"); | |
| max_val = 0; | |
| lengths = CPU_SCACHE_CHAIN_LENGTHS (cpu); | |
| for (i = 1; i < CPU_SCACHE_MAX_CHAIN_LENGTH (cpu); ++i) | |
| if (lengths[i] > max_val) | |
| max_val = lengths[i]; | |
| for (i = 1; i < CPU_SCACHE_MAX_CHAIN_LENGTH (cpu); ++i) | |
| { | |
| sim_io_printf (sd, " %2d: %*s: ", | |
| i, | |
| max_val < 10000 ? 5 : 10, | |
| sim_add_commas (buf, sizeof (buf), lengths[i])); | |
| sim_profile_print_bar (sd, PROFILE_HISTOGRAM_WIDTH, | |
| lengths[i], max_val); | |
| sim_io_printf (sd, "\n"); | |
| } | |
| sim_io_printf (sd, "\n"); | |
| } | |
| #endif /* WITH_SCACHE_PBB */ | |
| } |