• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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