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.
check_cache(cache_t * cache)43 static 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
parse_cache_opt(cache_t * cache,Char * opt,Char * optval)78 static 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
VG_(str_clo_cache_opt)114 Bool 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
umsg_cache_img(Char * desc,cache_t * c)135 static 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.
check_cache_or_override(Char * desc,cache_t * c,Bool clo_redefined)143 static 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
VG_(post_clo_init_configure_caches)160 void 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
VG_(print_cache_clo_opts)201 void 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