URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [sim/] [common/] [cgen-scache.c] - Rev 157
Go to most recent revision | Compare with Previous | Blame | View Log
/* 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 */ }
Go to most recent revision | Compare with Previous | Blame | View Log