2 Copyright 1992-1993, 1995, 1998-1999, 2000 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
29 The data cache could lead to incorrect results because it doesn't know
30 about volatile variables, thus making it impossible to debug
31 functions which use memory mapped I/O devices.
37 In general the dcache speeds up performance, some speed improvement
38 comes from the actual caching mechanism, but the major gain is in
39 the reduction of the remote protocol overhead; instead of reading
40 or writing a large area of memory in 4 byte requests, the cache
41 bundles up the requests into 32 byte (actually LINE_SIZE) chunks.
42 Reducing the overhead to an eighth of what it was. This is very
43 obvious when displaying a large amount of data,
48 ----------------------------
49 first time | 4 sec 2 sec improvement due to chunking
50 second time | 4 sec 0 sec improvement due to caching
52 The cache structure is unusual, we keep a number of cache blocks
53 (DCACHE_SIZE) and each one caches a LINE_SIZEed area of memory.
54 Within each line we remember the address of the line (always a
55 multiple of the LINE_SIZE) and a vector of bytes over the range.
56 There's another vector which contains the state of the bytes.
58 ENTRY_BAD means that the byte is just plain wrong, and has no
59 correspondence with anything else (as it would when the cache is
60 turned on, but nothing has been done to it.
62 ENTRY_DIRTY means that the byte has some data in it which should be
63 written out to the remote target one day, but contains correct
64 data. ENTRY_OK means that the data is the same in the cache as it
68 The ENTRY_DIRTY state is necessary because GDB likes to write large
69 lumps of memory in small bits. If the caching mechanism didn't
70 maintain the DIRTY information, then something like a two byte
71 write would mean that the entire cache line would have to be read,
72 the two bytes modified and then written out again. The alternative
73 would be to not read in the cache line in the first place, and just
74 write the two bytes directly into target memory. The trouble with
75 that is that it really nails performance, because of the remote
76 protocol overhead. This way, all those little writes are bundled
77 up into an entire cache line write in one go, without having to
78 read the cache line in the first place.
84 /* This value regulates the number of cache blocks stored.
85 Smaller values reduce the time spent searching for a cache
86 line, and reduce memory requirements, but increase the risk
87 of a line not being in memory */
89 #define DCACHE_SIZE 64
91 /* This value regulates the size of a cache line. Smaller values
92 reduce the time taken to read a single byte, but reduce overall
95 #define LINE_SIZE_POWER (5)
96 #define LINE_SIZE (1 << LINE_SIZE_POWER)
98 /* Each cache block holds LINE_SIZE bytes of data
99 starting at a multiple-of-LINE_SIZE address. */
101 #define LINE_SIZE_MASK ((LINE_SIZE - 1))
102 #define XFORM(x) ((x) & LINE_SIZE_MASK)
103 #define MASK(x) ((x) & ~LINE_SIZE_MASK)
106 #define ENTRY_BAD 0 /* data at this byte is wrong */
107 #define ENTRY_DIRTY 1 /* data at this byte needs to be written back */
108 #define ENTRY_OK 2 /* data at this byte is same as in memory */
113 struct dcache_block
*p
; /* next in list */
114 CORE_ADDR addr
; /* Address for which data is recorded. */
115 char data
[LINE_SIZE
]; /* bytes at given address */
116 unsigned char state
[LINE_SIZE
]; /* what state the data is in */
118 /* whether anything in state is dirty - used to speed up the
129 struct dcache_block
*free_head
;
130 struct dcache_block
*free_tail
;
133 struct dcache_block
*valid_head
;
134 struct dcache_block
*valid_tail
;
136 /* The cache itself. */
137 struct dcache_block
*the_cache
;
139 /* potentially, if the cache was enabled, and then turned off, and
140 then turned on again, the stuff in it could be stale, so this is
145 static int dcache_poke_byte (DCACHE
*dcache
, CORE_ADDR addr
, char *ptr
);
147 static int dcache_peek_byte (DCACHE
*dcache
, CORE_ADDR addr
, char *ptr
);
149 static struct dcache_block
*dcache_hit (DCACHE
*dcache
, CORE_ADDR addr
);
151 static int dcache_write_line (DCACHE
*dcache
, struct dcache_block
*db
);
153 static int dcache_read_line (DCACHE
*dcache
, struct dcache_block
*db
);
155 static struct dcache_block
*dcache_alloc (DCACHE
*dcache
, CORE_ADDR addr
);
157 static int dcache_writeback (DCACHE
*dcache
);
159 static void dcache_info (char *exp
, int tty
);
161 void _initialize_dcache (void);
163 static int dcache_enabled_p
= 0;
165 DCACHE
*last_cache
; /* Used by info dcache */
168 /* Free all the data cache blocks, thus discarding all cached data. */
171 dcache_invalidate (DCACHE
*dcache
)
174 dcache
->valid_head
= 0;
175 dcache
->valid_tail
= 0;
177 dcache
->free_head
= 0;
178 dcache
->free_tail
= 0;
180 for (i
= 0; i
< DCACHE_SIZE
; i
++)
182 struct dcache_block
*db
= dcache
->the_cache
+ i
;
184 if (!dcache
->free_head
)
185 dcache
->free_head
= db
;
187 dcache
->free_tail
->p
= db
;
188 dcache
->free_tail
= db
;
192 dcache
->cache_has_stuff
= 0;
197 /* If addr is present in the dcache, return the address of the block
200 static struct dcache_block
*
201 dcache_hit (DCACHE
*dcache
, CORE_ADDR addr
)
203 register struct dcache_block
*db
;
205 /* Search all cache blocks for one that is at this address. */
206 db
= dcache
->valid_head
;
210 if (MASK (addr
) == db
->addr
)
221 /* Make sure that anything in this line which needs to
225 dcache_write_line (DCACHE
*dcache
, register struct dcache_block
*db
)
232 for (s
= 0; s
< LINE_SIZE
; s
++)
234 if (db
->state
[s
] == ENTRY_DIRTY
)
237 for (e
= s
; e
< LINE_SIZE
; e
++, len
++)
238 if (db
->state
[e
] != ENTRY_DIRTY
)
241 /* all bytes from s..s+len-1 need to
246 int t
= do_xfer_memory (db
->addr
+ s
+ done
,
253 memset (db
->state
+ s
, ENTRY_OK
, len
);
263 /* Read cache line */
265 dcache_read_line (DCACHE
*dcache
, struct dcache_block
*db
)
272 /* If there are any dirty bytes in the line, it must be written
273 before a new line can be read */
276 if (!dcache_write_line (dcache
, db
))
286 res
= do_xfer_memory (memaddr
, myaddr
, len
, 0);
295 memset (db
->state
, ENTRY_OK
, sizeof (db
->data
));
301 /* Get a free cache block, put or keep it on the valid list,
302 and return its address. */
304 static struct dcache_block
*
305 dcache_alloc (DCACHE
*dcache
, CORE_ADDR addr
)
307 register struct dcache_block
*db
;
309 if (dcache_enabled_p
== 0)
312 /* Take something from the free list */
313 db
= dcache
->free_head
;
316 dcache
->free_head
= db
->p
;
320 /* Nothing left on free list, so grab one from the valid list */
321 db
= dcache
->valid_head
;
323 if (!dcache_write_line (dcache
, db
))
326 dcache
->valid_head
= db
->p
;
329 db
->addr
= MASK(addr
);
332 memset (db
->state
, ENTRY_BAD
, sizeof (db
->data
));
334 /* append this line to end of valid list */
335 if (!dcache
->valid_head
)
336 dcache
->valid_head
= db
;
338 dcache
->valid_tail
->p
= db
;
339 dcache
->valid_tail
= db
;
345 /* Writeback any dirty lines to the remote. */
347 dcache_writeback (DCACHE
*dcache
)
349 struct dcache_block
*db
;
351 db
= dcache
->valid_head
;
355 if (!dcache_write_line (dcache
, db
))
363 /* Using the data cache DCACHE return the contents of the byte at
364 address ADDR in the remote machine.
366 Returns 0 on error. */
369 dcache_peek_byte (DCACHE
*dcache
, CORE_ADDR addr
, char *ptr
)
371 register struct dcache_block
*db
= dcache_hit (dcache
, addr
);
375 db
= dcache_alloc (dcache
, addr
);
380 if (db
->state
[XFORM (addr
)] == ENTRY_BAD
)
382 if (!dcache_read_line(dcache
, db
))
386 *ptr
= db
->data
[XFORM (addr
)];
391 /* Write the byte at PTR into ADDR in the data cache.
392 Return zero on write error.
396 dcache_poke_byte (DCACHE
*dcache
, CORE_ADDR addr
, char *ptr
)
398 register struct dcache_block
*db
= dcache_hit (dcache
, addr
);
402 db
= dcache_alloc (dcache
, addr
);
407 db
->data
[XFORM (addr
)] = *ptr
;
408 db
->state
[XFORM (addr
)] = ENTRY_DIRTY
;
413 /* Initialize the data cache. */
417 int csize
= sizeof (struct dcache_block
) * DCACHE_SIZE
;
420 dcache
= (DCACHE
*) xmalloc (sizeof (*dcache
));
422 dcache
->the_cache
= (struct dcache_block
*) xmalloc (csize
);
423 memset (dcache
->the_cache
, 0, csize
);
425 dcache_invalidate (dcache
);
431 /* Free a data cache */
433 dcache_free (DCACHE
*dcache
)
435 if (last_cache
== dcache
)
438 xfree (dcache
->the_cache
);
442 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
443 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
446 Returns length of data written or read; 0 for error.
448 This routine is indended to be called by remote_xfer_ functions. */
451 dcache_xfer_memory (DCACHE
*dcache
, CORE_ADDR memaddr
, char *myaddr
, int len
,
456 if (dcache_enabled_p
)
458 int (*xfunc
) (DCACHE
*dcache
, CORE_ADDR addr
, char *ptr
);
459 xfunc
= should_write
? dcache_poke_byte
: dcache_peek_byte
;
461 for (i
= 0; i
< len
; i
++)
463 if (!xfunc (dcache
, memaddr
+ i
, myaddr
+ i
))
468 dcache_writeback (dcache
);
470 dcache
->cache_has_stuff
= 1;
474 if (dcache
->cache_has_stuff
)
475 dcache_invalidate (dcache
);
477 len
= do_xfer_memory(memaddr
, myaddr
, len
, should_write
);
483 dcache_info (char *exp
, int tty
)
485 struct dcache_block
*p
;
487 if (!dcache_enabled_p
)
489 printf_filtered ("Dcache not enabled\n");
492 printf_filtered ("Dcache enabled, line width %d, depth %d\n",
493 LINE_SIZE
, DCACHE_SIZE
);
497 printf_filtered ("Cache state:\n");
499 for (p
= last_cache
->valid_head
; p
; p
= p
->p
)
502 printf_filtered ("Line at %s, referenced %d times\n",
503 paddr (p
->addr
), p
->refs
);
505 for (j
= 0; j
< LINE_SIZE
; j
++)
506 printf_filtered ("%02x", p
->data
[j
] & 0xFF);
507 printf_filtered ("\n");
509 for (j
= 0; j
< LINE_SIZE
; j
++)
510 printf_filtered ("%2x", p
->state
[j
]);
511 printf_filtered ("\n");
516 /* Turn dcache on or off. */
518 set_dcache_state (int what
)
520 dcache_enabled_p
= !!what
;
524 _initialize_dcache (void)
527 (add_set_cmd ("remotecache", class_support
, var_boolean
,
528 (char *) &dcache_enabled_p
,
530 Set cache use for remote targets.\n\
531 When on, use data caching for remote targets. For many remote targets\n\
532 this option can offer better throughput for reading target memory.\n\
533 Unfortunately, gdb does not currently know anything about volatile\n\
534 registers and thus data caching will produce incorrect results with\n\
535 volatile registers are in use. By default, this option is off.",
539 add_info ("dcache", dcache_info
,
540 "Print information on the dcache performance.");
This page took 0.050467 seconds and 4 git commands to generate.