Following up on my recent posting regarding specializing on the
existing cache_component. Here is the patch which allows use of
cache_component and cache_line as base classes. The purpose of this is
to allow me to implement a target-specific cache with a unique cache
line implementation. The main changes are:
1) Make cache_line into a virtual base class. The original cache_line
class is now called internal_cache_line (it keeps its data internally)
and its functionality is unchanged.
2) Introduce a new cache_line_factory class which is used to allocate
cache lines. Each cache_component is now passed a reference to a
cache_line_factory which it uses to allocate its cache lines. An
instance called internal_line_factory is used to create lines of type
internal_cache_line.
3) The find mechanism of cache and cache_set previously passed cache
lines by assignment via reference arguments. This is no longer
possible with a virtual class implementation. The mechanism now
returns a pointer to the found line (if found) and NULL otherwise.
4) Similarly, the 'replace' method of cache_replacement_algorithm
previously passed in a new line and returned the old one by assignment
using reference arguments. Now, a pointer to the expelled line is
returned (if any --- all lines might be locked) and NULL otherwise.
The expelled line is updated using access methods. The 'replace'
method has been renamed to 'expell' since the line is no longer
replaced. This also eliminates construction and destruction overhead
for each cache miss. Also, the copy constructor and assignment
operator for cache_line are no longer necessary.
5) The 'insert' and 'extract' methods of cache_line are now declared
using a macro for the cartesian product of possible datatypes as is
common elsewhere. It was not possible to instantiate the necessary
termplate methods automatically in the virtual base class.
6) The changes the sid/component/cfgroot were found necessary while
debugging problems in my implementation.
7) The changes to main/dynamic/commonCfg.h were necessary in order to
allow me to inherit from CacheCfg for my specialized cache
configurator and to get a handle to the loader configuration from the
SessionCfg so that I could connect the loader's "set-endian" pin to my
cache line implementation.
I have tested this against my own port (with specialized cache and
cache lines) as well as against xstormy16. All of the sid testsuite
checks without regression (including the cache-specific tests). I'm
seeking comments and approval to commit.
Regards,
Dave
------------------------------------------------------------------------
2004-04-27 Dave Brolley <brolley@redhat.com>
* cache.cxx: Update calls to cache::find.
* cacheutil.cxx (cache_set::allocate_lines): Now takes cache index as
an argument. Update all callers.
(cache_set::find): Now returns a pointer to the line, if found. Update
all callers.
(cache::find): Ditto.
(cache_set::expell_line): Update the status of the expelled line.
* cacheutil.h (cache_line_factory::make_line): Now takes cache index as
an argument. Update all callers.
(cache_set::allocate_lines): Now takes cache index as
an argument. Update all callers.
(cache_set::find): Now returns a pointer to the line, if found. Update
all callers.
(cache::find): Ditto.
2004-04-27 Dave Brolley <brolley@redhat.com>
* cacheutil.h (cache_line): Removed copy constructor. Now virtual base
class.
(cache_line::operator=): Removed.
(internal_cache_line): New class implements former cache_line class.
(cache_set): Now takes cache_line_factory.
(allocate_lines): New method moves line allocation from the constructor.
(cache_set::set_line): Now takes reference to cache_line.
(cache_set::replace_line): Renamed to expell_line. Now returns a pointer
to the expelled line.
(cache): Now takes cache_line_factory argument.
(cache::init): New method moves set allocation from the constructor.
(cache_set::expell_line): Renamed to expell_line. Now returns a pointer
to the expelled line.
(cache_line_factory): New class.
* cacheutil.cxx (cache_line): Removed copy constructor. Now virtual base
class.
(cache_line::operator=): Removed.
(internal_cache_line): New class implements former cache_line class.
(cache_set): Now takes cache_line_factory.
(allocate_lines): New method moves line allocation from the constructor.
(cache_set::set_line): Now takes reference to cache_line.
(dummy): Now internal to cache_set::find.
(cache_set::replace_line): Renamed to expell_line. Now returns a pointer
to the expelled line.
(cache): Now takes cache_line_factory argument.
(cache::init): New method moves set allocation from the constructor.
(cache_set::expell_line): Renamed to expell_line. Now returns a pointer
to the expelled line.
* cache.h (cache_replacement_algorithm::expell): Renamed from 'replace'.
Returns a pointer to the expelled line. Update specializations.
(cache_component): Now takes a cache_line_factory as an argument.
Private data now protected.
(line_factory): New member of cache_component.
(~cache_component): Now virtual.
(CacheCreate): Pass internal_line_factory to cache_component.
* cache.cxx (line_sizes): Make it static.
(line_sizes): Ditto.
(replacement_algorithms): Ditto.
(internal_line_factory): New static cache_line_factory.
(cache_component): Now takes a cache_line_factory as an argument. Pass
the cache line factory to the constructor for acache. Save a reference
to the line factory. Call acache.init
(write_any): Rewrite to use cache::expell_line instead of the former
cache::replace.
(read_any): Ditto.
(cache_replacement_algorithm::expell): Renamed from 'replace'. Returns
a pointer to the expelled line. Update all callers and specializations.
(CacheCreate): Pass internal_line_factory to cache_component.
2004-04-27 Dave Brolley <brolley@redhat.com>
* compConfig.cxx (register_dso): Check dl_handle before attempting to
open ".a".
* Makefile.am (libconfig_la_DEPENDENCIES): Add @LIBLTDL@.
* Makefile.in: Regenerated.
2004-04-27 Dave Brolley <brolley@redhat.com>
* commonCfg.h (CacheCfg::compute_comptype): Now virtual.
(SessionCfg::get_loader): New method.