1/*--------------------------------------------------------------------*/
2/*--- Cachegrind: cache configuration.                             ---*/
3/*--- The architecture specific void VG_(configure_caches) are     ---*/
4/*--- located in the cg-<architecture>.c files.                    ---*/
5/*---                                                    cg-arch.c ---*/
6/*--------------------------------------------------------------------*/
7
8/*
9   This file is part of Cachegrind, a Valgrind tool for cache
10   profiling programs.
11
12   Copyright (C) 2011-2012 Nicholas Nethercote
13      njn@valgrind.org
14
15   This program is free software; you can redistribute it and/or
16   modify it under the terms of the GNU General Public License as
17   published by the Free Software Foundation; either version 2 of the
18   License, or (at your option) any later version.
19
20   This program is distributed in the hope that it will be useful, but
21   WITHOUT ANY WARRANTY; without even the implied warranty of
22   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23   General Public License for more details.
24
25   You should have received a copy of the GNU General Public License
26   along with this program; if not, write to the Free Software
27   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
28   02111-1307, USA.
29
30   The GNU General Public License is contained in the file COPYING.
31*/
32
33#include "pub_tool_basics.h"
34#include "pub_tool_libcassert.h"
35#include "pub_tool_libcbase.h"
36#include "pub_tool_libcprint.h"
37#include "pub_tool_options.h"
38
39#include "cg_arch.h"
40
41// Checks cache config is ok.  Returns NULL if ok, or a pointer to an error
42// string otherwise.
43static Char* check_cache(cache_t* cache)
44{
45   // Simulator requires set count to be a power of two.
46   if ((cache->size % (cache->line_size * cache->assoc) != 0) ||
47       (-1 == VG_(log2)(cache->size/cache->line_size/cache->assoc)))
48   {
49      return "Cache set count is not a power of two.\n";
50   }
51
52   // Simulator requires line size to be a power of two.
53   if (-1 == VG_(log2)(cache->line_size)) {
54      return "Cache line size is not a power of two.\n";
55   }
56
57   // Then check line size >= 16 -- any smaller and a single instruction could
58   // straddle three cache lines, which breaks a simulation assertion and is
59   // stupid anyway.
60   if (cache->line_size < MIN_LINE_SIZE) {
61      return "Cache line size is too small.\n";
62   }
63
64   /* Then check cache size > line size (causes seg faults if not). */
65   if (cache->size <= cache->line_size) {
66      return "Cache size <= line size.\n";
67   }
68
69   /* Then check assoc <= (size / line size) (seg faults otherwise). */
70   if (cache->assoc > (cache->size / cache->line_size)) {
71      return "Cache associativity > (size / line size).\n";
72   }
73
74   return NULL;
75}
76
77
78static void parse_cache_opt ( cache_t* cache, Char* opt, Char* optval )
79{
80   Long i1, i2, i3;
81   Char* endptr;
82   Char* checkRes;
83
84   // Option argument looks like "65536,2,64".  Extract them.
85   i1 = VG_(strtoll10)(optval,   &endptr); if (*endptr != ',')  goto bad;
86   i2 = VG_(strtoll10)(endptr+1, &endptr); if (*endptr != ',')  goto bad;
87   i3 = VG_(strtoll10)(endptr+1, &endptr); if (*endptr != '\0') goto bad;
88
89   // Check for overflow.
90   cache->size      = (Int)i1;
91   cache->assoc     = (Int)i2;
92   cache->line_size = (Int)i3;
93   if (cache->size      != i1) goto overflow;
94   if (cache->assoc     != i2) goto overflow;
95   if (cache->line_size != i3) goto overflow;
96
97   checkRes = check_cache(cache);
98   if (checkRes) {
99      VG_(fmsg)("%s", checkRes);
100      goto bad;
101   }
102
103   return;
104
105  bad:
106   VG_(fmsg_bad_option)(opt, "");
107
108  overflow:
109   VG_(fmsg_bad_option)(opt,
110      "One of the cache parameters was too large and overflowed.\n");
111}
112
113
114Bool VG_(str_clo_cache_opt)(Char *arg,
115                            cache_t* clo_I1c,
116                            cache_t* clo_D1c,
117                            cache_t* clo_LLc)
118{
119   Char* tmp_str;
120
121   if      VG_STR_CLO(arg, "--I1", tmp_str) {
122      parse_cache_opt(clo_I1c, arg, tmp_str);
123      return True;
124   } else if VG_STR_CLO(arg, "--D1", tmp_str) {
125      parse_cache_opt(clo_D1c, arg, tmp_str);
126      return True;
127   } else if (VG_STR_CLO(arg, "--L2", tmp_str) || // for backwards compatibility
128              VG_STR_CLO(arg, "--LL", tmp_str)) {
129      parse_cache_opt(clo_LLc, arg, tmp_str);
130      return True;
131   } else
132      return False;
133}
134
135static void umsg_cache_img(Char* desc, cache_t* c)
136{
137   VG_(umsg)("  %s: %'d B, %d-way, %d B lines\n", desc,
138             c->size, c->assoc, c->line_size);
139}
140
141// Verifies if c is a valid cache.
142// An invalid value causes an assert, unless clo_redefined is True.
143static void check_cache_or_override(Char* desc, cache_t* c, Bool clo_redefined)
144{
145   Char* checkRes;
146
147   checkRes = check_cache(c);
148   if (checkRes) {
149      VG_(umsg)("Auto-detected %s cache configuration not supported: %s",
150                desc, checkRes);
151      umsg_cache_img(desc, c);
152      if (!clo_redefined) {
153         VG_(umsg)("As it probably should be supported, please report a bug!\n");
154         VG_(umsg)("Bypass this message by using option --%s=...\n", desc);
155         tl_assert(0);
156      }
157   }
158}
159
160void VG_(post_clo_init_configure_caches)(cache_t* I1c,
161                                         cache_t* D1c,
162                                         cache_t* LLc,
163                                         cache_t* clo_I1c,
164                                         cache_t* clo_D1c,
165                                         cache_t* clo_LLc)
166{
167#define DEFINED(L)   (-1 != L->size  || -1 != L->assoc || -1 != L->line_size)
168
169   // Count how many were defined on the command line.
170   Bool all_caches_clo_defined =
171      (DEFINED(clo_I1c) &&
172       DEFINED(clo_D1c) &&
173       DEFINED(clo_LLc));
174
175   // Set the cache config (using auto-detection, if supported by the
176   // architecture).
177   VG_(configure_caches)( I1c, D1c, LLc, all_caches_clo_defined );
178
179   // Check the default/auto-detected values.
180   // Allow the user to override invalid auto-detected caches
181   // with command line.
182   check_cache_or_override ("I1", I1c, DEFINED(clo_I1c));
183   check_cache_or_override ("D1", D1c, DEFINED(clo_D1c));
184   check_cache_or_override ("LL", LLc, DEFINED(clo_LLc));
185
186   // Then replace with any defined on the command line.  (Already checked in
187   // VG(parse_clo_cache_opt)().)
188   if (DEFINED(clo_I1c)) { *I1c = *clo_I1c; }
189   if (DEFINED(clo_D1c)) { *D1c = *clo_D1c; }
190   if (DEFINED(clo_LLc)) { *LLc = *clo_LLc; }
191
192   if (VG_(clo_verbosity) >= 2) {
193      VG_(umsg)("Cache configuration used:\n");
194      umsg_cache_img ("I1", I1c);
195      umsg_cache_img ("D1", D1c);
196      umsg_cache_img ("LL", LLc);
197   }
198#undef DEFINED
199}
200
201void VG_(print_cache_clo_opts)()
202{
203   VG_(printf)(
204"    --I1=<size>,<assoc>,<line_size>  set I1 cache manually\n"
205"    --D1=<size>,<assoc>,<line_size>  set D1 cache manually\n"
206"    --LL=<size>,<assoc>,<line_size>  set LL cache manually\n"
207               );
208}
209