base: const-correctness of Allocator interface

This patch adds const qualifiers to the functions Allocator::consumed,
Allocator::overhead, Allocator::avail, and Range_allocator::valid_addr.

Fixes #1481
This commit is contained in:
Norman Feske 2015-04-14 14:14:20 +02:00 committed by Christian Helmuth
parent 847ddbf72e
commit eaab23c012
23 changed files with 115 additions and 111 deletions

View File

@ -43,19 +43,19 @@ namespace Genode
** Allocator interface **
*************************/
bool alloc(size_t size, void **out_addr) {
bool alloc(size_t size, void **out_addr) override {
return _alloc->alloc(size, out_addr); }
void free(void *addr, size_t size) {
void free(void *addr, size_t size) override {
_alloc->free(addr, size); }
size_t consumed() {
size_t consumed() const override {
PDBG("Unexpected call");
while (1) ;
return 0;
}
size_t overhead(size_t size) {
size_t overhead(size_t size) const override {
PDBG("Unexpected call");
while (1) ;
return 0;

View File

@ -44,18 +44,18 @@ class Genode::Early_translations_allocator : public Genode::Core_mem_translator
public:
Early_translations_allocator() { }
int add_range(addr_t base, size_t size) { return -1; }
int remove_range(addr_t base, size_t size) { return -1; }
Alloc_return alloc_aligned(size_t, void **, int, addr_t, addr_t) {
int add_range(addr_t base, size_t size) override { return -1; }
int remove_range(addr_t base, size_t size) override { return -1; }
Alloc_return alloc_aligned(size_t, void **, int, addr_t, addr_t) override {
return Alloc_return::RANGE_CONFLICT; }
Alloc_return alloc_addr(size_t size, addr_t addr) {
Alloc_return alloc_addr(size_t size, addr_t addr) override {
return Alloc_return::RANGE_CONFLICT; }
void free(void *addr) {}
size_t avail() { return 0; }
bool valid_addr(addr_t addr) { return false; }
bool alloc(size_t size, void **out_addr) { return false; }
void free(void *addr, size_t) { }
size_t overhead(size_t size) { return 0; }
void free(void *addr) override { }
size_t avail() const override { return 0; }
bool valid_addr(addr_t addr) const override { return false; }
bool alloc(size_t size, void **out_addr) override { return false; }
void free(void *addr, size_t) override { }
size_t overhead(size_t size) const override { return 0; }
bool need_size_for_free() const override { return false; }
void * phys_addr(void * addr) { return addr; }
void * virt_addr(void * addr) { return addr; }

View File

@ -102,10 +102,10 @@ class Genode::Page_slab : public Genode::Allocator
/**
* Returns number of used slab blocks
*/
size_t _slab_blocks_in_use()
size_t _slab_blocks_in_use() const
{
size_t cnt = 0;
for (List_element<Slab_block> *le = _b_list.first();
for (List_element<Slab_block> const *le = _b_list.first();
le; le = le->next(), cnt++) ;
return cnt;
}
@ -220,10 +220,10 @@ class Genode::Page_slab : public Genode::Allocator
* Allocator interface **
************************/
bool alloc(size_t, void **addr) { return (*addr = alloc()); }
void free(void *addr, size_t) { free(addr); }
size_t consumed() { return SLAB_BLOCK_SIZE * _slab_blocks_in_use(); }
size_t overhead(size_t) { return SLAB_BLOCK_SIZE/SLABS_PER_BLOCK; }
bool alloc(size_t, void **addr) override { return (*addr = alloc()); }
void free(void *addr, size_t) override { free(addr); }
size_t consumed() const override { return SLAB_BLOCK_SIZE * _slab_blocks_in_use(); }
size_t overhead(size_t) const override { return SLAB_BLOCK_SIZE/SLABS_PER_BLOCK; }
bool need_size_for_free() const override { return false; }
};

View File

@ -59,14 +59,13 @@ namespace Genode {
return Alloc_return::OK;;
}
int add_range(addr_t, size_t) { return 0; }
int remove_range(addr_t, size_t) { return 0; }
void free(void *) { }
void free(void *, size_t) { }
size_t avail() { return ~0; }
bool valid_addr(addr_t) { return true; }
size_t overhead(size_t) { return 0; }
int add_range(addr_t, size_t) override { return 0; }
int remove_range(addr_t, size_t) override { return 0; }
void free(void *) override { }
void free(void *, size_t) override { }
size_t avail() const override { return ~0; }
bool valid_addr(addr_t) const override { return true; }
size_t overhead(size_t) const override { return 0; }
bool need_size_for_free() const override { return true; }
};

View File

@ -95,12 +95,12 @@ struct Genode::Allocator : Deallocator
/**
* Return total amount of backing store consumed by the allocator
*/
virtual size_t consumed() { return 0; }
virtual size_t consumed() const { return 0; }
/**
* Return meta-data overhead per block
*/
virtual size_t overhead(size_t size) = 0;
virtual size_t overhead(size_t size) const = 0;
/**
* Allocate block and signal error as an exception
@ -193,7 +193,7 @@ struct Genode::Range_allocator : Allocator
* Note that the returned value is not neccessarily allocatable
* because the memory may be fragmented.
*/
virtual size_t avail() = 0;
virtual size_t avail() const = 0;
/**
* Check if address is inside an allocated block
@ -203,7 +203,7 @@ struct Genode::Range_allocator : Allocator
* \return true if address is inside an allocated block, false
* otherwise
*/
virtual bool valid_addr(addr_t addr) = 0;
virtual bool valid_addr(addr_t addr) const = 0;
};

View File

@ -250,18 +250,18 @@ class Genode::Allocator_avl_base : public Range_allocator
addr_t from = 0, addr_t to = ~0UL) override;
Alloc_return alloc_addr(size_t size, addr_t addr) override;
void free(void *addr) override;
size_t avail() override;
bool valid_addr(addr_t addr) override;
size_t avail() const override;
bool valid_addr(addr_t addr) const override;
/*************************
** Allocator interface **
*************************/
bool alloc(size_t size, void **out_addr) {
bool alloc(size_t size, void **out_addr) override {
return (Allocator_avl_base::alloc_aligned(size, out_addr).is_ok()); }
void free(void *addr, size_t) { free(addr); }
void free(void *addr, size_t) override { free(addr); }
/**
* Return size of block at specified address
@ -278,7 +278,7 @@ class Genode::Allocator_avl_base : public Range_allocator
* The 'sizeof(umword_t)' represents the overhead of the meta-data
* slab allocator.
*/
size_t overhead(size_t) { return sizeof(Block) + sizeof(umword_t); }
size_t overhead(size_t) const override { return sizeof(Block) + sizeof(umword_t); }
bool need_size_for_free() const override { return false; }
};

View File

@ -93,7 +93,7 @@ class Genode::Allocator_guard : public Allocator
/**
* Return amount of backing store consumed by the allocator
*/
size_t consumed() override { return _consumed; }
size_t consumed() const override { return _consumed; }
/**
* Return allocation limit
@ -103,7 +103,7 @@ class Genode::Allocator_guard : public Allocator
/**
* Return meta-data overhead per block
*/
size_t overhead(size_t size) override { return _allocator->overhead(size); }
size_t overhead(size_t size) const override { return _allocator->overhead(size); }
bool need_size_for_free() const override {
return _allocator->need_size_for_free(); }

View File

@ -170,8 +170,8 @@ class Genode::Heap : public Allocator
bool alloc(size_t, void **) override;
void free(void *, size_t) override;
size_t consumed() override { return _quota_used; }
size_t overhead(size_t size) override { return _alloc.overhead(size); }
size_t consumed() const override { return _quota_used; }
size_t overhead(size_t size) const override { return _alloc.overhead(size); }
bool need_size_for_free() const override { return false; }
};
@ -210,8 +210,8 @@ class Genode::Sliced_heap : public Allocator
bool alloc(size_t, void **);
void free(void *, size_t);
size_t consumed() { return _consumed; }
size_t overhead(size_t size);
size_t consumed() const { return _consumed; }
size_t overhead(size_t size) const;
bool need_size_for_free() const override { return false; }
};

View File

@ -265,10 +265,10 @@ class Genode::Slab : public Allocator
* The 'size' parameter is ignored as only slab entries with
* preconfigured slab-entry size are allocated.
*/
bool alloc(size_t size, void **addr);
void free(void *addr, size_t) { free(addr); }
size_t consumed();
size_t overhead(size_t) { return _block_size/_num_elem; }
bool alloc(size_t size, void **addr) override;
void free(void *addr, size_t) override { free(addr); }
size_t consumed() const override;
size_t overhead(size_t) const override { return _block_size/_num_elem; }
bool need_size_for_free() const override { return false; }
};

View File

@ -86,13 +86,13 @@ class Genode::Synchronized_allocator : public Allocator
_alloc.free(addr, size);
}
size_t consumed() override
size_t consumed() const override
{
Lock::Guard lock_guard(*_lock);
return _alloc.consumed();
}
size_t overhead(size_t size) override
size_t overhead(size_t size) const override
{
Lock::Guard lock_guard(*_lock);
return _alloc.overhead(size);
@ -191,13 +191,13 @@ class Genode::Synchronized_range_allocator : public Range_allocator
_alloc.free(addr, size);
}
size_t consumed() override
size_t consumed() const override
{
Lock::Guard lock_guard(*_lock);
return _alloc.consumed();
}
size_t overhead(size_t size) override
size_t overhead(size_t size) const override
{
Lock::Guard lock_guard(*_lock);
return _alloc.overhead(size);
@ -245,13 +245,13 @@ class Genode::Synchronized_range_allocator : public Range_allocator
_alloc.free(addr);
}
size_t avail() override
size_t avail() const override
{
Lock::Guard lock_guard(*_lock);
return _alloc.avail();
}
bool valid_addr(addr_t addr) override
bool valid_addr(addr_t addr) const override
{
Lock::Guard lock_guard(*_lock);
return _alloc.valid_addr(addr);

View File

@ -358,14 +358,14 @@ bool Allocator_avl_base::any_block_addr(addr_t *out_addr)
}
size_t Allocator_avl_base::avail()
size_t Allocator_avl_base::avail() const
{
Block *b = static_cast<Block *>(_addr_tree.first());
return b ? b->avail_in_subtree() : 0;
}
bool Allocator_avl_base::valid_addr(addr_t addr)
bool Allocator_avl_base::valid_addr(addr_t addr) const
{
Block *b = _find_by_address(addr);
return b ? true : false;

View File

@ -285,7 +285,7 @@ void *Slab::first_used_elem()
}
size_t Slab::consumed()
size_t Slab::consumed() const
{
/* count number of slab blocks */
unsigned sb_cnt = 0;

View File

@ -120,4 +120,7 @@ void Sliced_heap::free(void *addr, size_t size)
}
size_t Sliced_heap::overhead(size_t size) { return align_addr(size + sizeof(Block), 12) - size; }
size_t Sliced_heap::overhead(size_t size) const
{
return align_addr(size + sizeof(Block), 12) - size;
}

View File

@ -159,15 +159,16 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator
** Range allocator interface **
*******************************/
int add_range(addr_t base, size_t size) { return -1; }
int remove_range(addr_t base, size_t size) { return -1; }
int add_range(addr_t base, size_t size) override { return -1; }
int remove_range(addr_t base, size_t size) override { return -1; }
Alloc_return alloc_aligned(size_t size, void **out_addr,
int align = 0, addr_t from = 0, addr_t to = ~0UL);
Alloc_return alloc_addr(size_t size, addr_t addr) {
int align = 0, addr_t from = 0,
addr_t to = ~0UL) override;
Alloc_return alloc_addr(size_t size, addr_t addr) override {
return Alloc_return::RANGE_CONFLICT; }
void free(void *addr) {}
size_t avail() { return _phys_alloc->avail(); }
bool valid_addr(addr_t addr) {
void free(void *addr) override { }
size_t avail() const override { return _phys_alloc->avail(); }
bool valid_addr(addr_t addr) const override {
return _virt_alloc->valid_addr(addr); }
@ -175,11 +176,11 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator
** Allocator interface **
*************************/
bool alloc(size_t size, void **out_addr) {
bool alloc(size_t size, void **out_addr) override {
return alloc_aligned(size, out_addr).is_ok(); }
void free(void *addr, size_t) { free(addr); }
size_t consumed() { return _phys_alloc->consumed(); }
size_t overhead(size_t size) {
void free(void *addr, size_t) override { free(addr); }
size_t consumed() const override { return _phys_alloc->consumed(); }
size_t overhead(size_t size) const override {
return _phys_alloc->overhead(size); }
bool need_size_for_free() const override {
return _phys_alloc->need_size_for_free(); }
@ -269,39 +270,40 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator
** Range allocator interface **
*******************************/
int add_range(addr_t base, size_t size) { return -1; }
int remove_range(addr_t base, size_t size) { return -1; }
Alloc_return alloc_addr(size_t size, addr_t addr) {
int add_range(addr_t base, size_t size) override { return -1; }
int remove_range(addr_t base, size_t size) override { return -1; }
Alloc_return alloc_addr(size_t size, addr_t addr) override {
return Alloc_return::RANGE_CONFLICT; }
Alloc_return alloc_aligned(size_t size, void **out_addr, int align = 0, addr_t from = 0, addr_t to = ~0UL)
Alloc_return alloc_aligned(size_t size, void **out_addr, int align = 0,
addr_t from = 0, addr_t to = ~0UL) override
{
Lock::Guard lock_guard(_lock);
return _mem_alloc.alloc_aligned(size, out_addr, align, from, to);
}
void free(void *addr)
void free(void *addr) override
{
Lock::Guard lock_guard(_lock);
return _mem_alloc.free(addr);
}
size_t avail() { return _phys_alloc.avail(); }
size_t avail() const override { return _phys_alloc.avail(); }
bool valid_addr(addr_t addr) { return _virt_alloc.valid_addr(addr); }
bool valid_addr(addr_t addr) const override { return _virt_alloc.valid_addr(addr); }
/*************************
** Allocator interface **
*************************/
bool alloc(size_t size, void **out_addr) {
bool alloc(size_t size, void **out_addr) override {
return alloc_aligned(size, out_addr).is_ok(); }
void free(void *addr, size_t) { free(addr); }
void free(void *addr, size_t) override { free(addr); }
size_t consumed() { return _phys_alloc.consumed(); }
size_t overhead(size_t size) { return _phys_alloc.overhead(size); }
size_t consumed() const override { return _phys_alloc.consumed(); }
size_t overhead(size_t size) const override { return _phys_alloc.overhead(size); }
bool need_size_for_free() const override {
return _phys_alloc.need_size_for_free(); }

View File

@ -45,12 +45,12 @@ struct Allocator : Genode::Allocator
Allocator() { }
virtual ~Allocator() { }
Genode::size_t consumed() override
Genode::size_t consumed() const override
{
return heap.consumed();
}
Genode::size_t overhead(Genode::size_t size) override
Genode::size_t overhead(Genode::size_t size) const override
{
return heap.overhead(size);
}

View File

@ -99,7 +99,7 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
/**
* Allocate
*/
bool alloc(size_t size, void **out_addr)
bool alloc(size_t size, void **out_addr) override
{
bool done = _range.alloc(size, out_addr);
@ -115,8 +115,8 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
return _range.alloc(size, out_addr);
}
void free(void *addr, size_t /* size */) { }
size_t overhead(size_t size) { return 0; }
void free(void *addr, size_t /* size */) override { }
size_t overhead(size_t size) const override { return 0; }
bool need_size_for_free() const override { return false; }
/**

View File

@ -102,7 +102,7 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
/**
* Allocate
*/
bool alloc(size_t size, void **out_addr)
bool alloc(size_t size, void **out_addr) override
{
bool done = _range.alloc(size, out_addr);
@ -118,8 +118,8 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
return _range.alloc(size, out_addr);
}
void free(void *addr, size_t /* size */) { }
size_t overhead(size_t size) { return 0; }
void free(void *addr, size_t /* size */) override { }
size_t overhead(size_t size) const override { return 0; }
bool need_size_for_free() const override { return false; }
/**

View File

@ -103,7 +103,7 @@ class Lx::Slab_backend_alloc : public Genode::Allocator,
/**
* Allocate
*/
bool alloc(size_t size, void **out_addr)
bool alloc(size_t size, void **out_addr) override
{
bool done = _range.alloc(size, out_addr);
@ -119,8 +119,8 @@ class Lx::Slab_backend_alloc : public Genode::Allocator,
return _range.alloc(size, out_addr);
}
void free(void *addr, size_t /* size */) { }
size_t overhead(size_t size) { return 0; }
void free(void *addr, size_t /* size */) override { }
size_t overhead(size_t size) const override { return 0; }
bool need_size_for_free() const override { return false; }
/**

View File

@ -151,8 +151,8 @@ namespace Allocator {
return addr;
}
void free(void *addr, size_t size) { _range.free(addr, size); }
size_t overhead(size_t size) { return 0; }
void free(void *addr, size_t size) override { _range.free(addr, size); }
size_t overhead(size_t size) const override { return 0; }
bool need_size_for_free() const override { return false; }
/**

View File

@ -70,7 +70,7 @@ class Malloc : public Genode::Allocator
Genode::Slab_alloc *_allocator[NUM_SLABS]; /* slab allocators */
Genode::Lock _lock;
unsigned long _slab_log2(unsigned long size)
unsigned long _slab_log2(unsigned long size) const
{
unsigned msb = Genode::log2(size);
/* size is greater than msb */
@ -100,7 +100,7 @@ class Malloc : public Genode::Allocator
* Allocator interface
*/
bool alloc(size_t size, void **out_addr)
bool alloc(size_t size, void **out_addr) override
{
Genode::Lock::Guard lock_guard(_lock);
@ -132,7 +132,7 @@ class Malloc : public Genode::Allocator
return true;
}
void free(void *ptr, size_t /* size */)
void free(void *ptr, size_t /* size */) override
{
Genode::Lock::Guard lock_guard(_lock);
@ -147,7 +147,7 @@ class Malloc : public Genode::Allocator
}
}
size_t overhead(size_t size)
size_t overhead(size_t size) const override
{
size += sizeof(Block_header);

View File

@ -67,7 +67,7 @@ class Genode::Packet_allocator : public Genode::Range_allocator
** Range-allocator interface **
*******************************/
int add_range(addr_t base, size_t size)
int add_range(addr_t base, size_t size) override
{
if (_base || _array) return -1;
@ -79,7 +79,7 @@ class Genode::Packet_allocator : public Genode::Range_allocator
return 0;
}
int remove_range(addr_t base, size_t size)
int remove_range(addr_t base, size_t size) override
{
if (_base != base) return -1;
@ -89,13 +89,13 @@ class Genode::Packet_allocator : public Genode::Range_allocator
}
Alloc_return alloc_aligned(size_t size, void **out_addr, int, addr_t,
addr_t)
addr_t) override
{
return alloc(size, out_addr) ? Alloc_return::OK
: Alloc_return::RANGE_CONFLICT;
}
bool alloc(size_t size, void **out_addr)
bool alloc(size_t size, void **out_addr) override
{
addr_t const cnt = (size % _block_size) ? size / _block_size + 1
: size / _block_size;
@ -124,7 +124,7 @@ class Genode::Packet_allocator : public Genode::Range_allocator
return false;
}
void free(void *addr, size_t size)
void free(void *addr, size_t size) override
{
addr_t i = (((addr_t)addr) - _base) / _block_size;
size_t cnt = (size % _block_size) ? size / _block_size + 1
@ -139,11 +139,11 @@ class Genode::Packet_allocator : public Genode::Range_allocator
*************/
bool need_size_for_free() const override { return false; }
void free(void *addr) { }
size_t overhead(size_t) { return 0;}
size_t avail() { return 0; }
bool valid_addr(addr_t) { return 0; }
Alloc_return alloc_addr(size_t, addr_t) {
void free(void *addr) override { }
size_t overhead(size_t) const override { return 0;}
size_t avail() const override { return 0; }
bool valid_addr(addr_t) const override { return 0; }
Alloc_return alloc_addr(size_t, addr_t) override {
return Alloc_return(Alloc_return::OUT_OF_METADATA); }
};

View File

@ -152,9 +152,9 @@ class Backing_store_allocator : public Allocator
destroy(env()->heap(), b);
}
size_t consumed() { return _consumed; }
size_t consumed() const { return _consumed; }
size_t overhead(size_t size) { return 0; }
size_t overhead(size_t size) const { return 0; }
bool need_size_for_free() const override { return false; }
};

View File

@ -42,7 +42,7 @@ namespace Genode {
_wrapped.free(addr, size);
}
size_t overhead(size_t size) override { return _wrapped.overhead(size); }
size_t overhead(size_t size) const override { return _wrapped.overhead(size); }
bool need_size_for_free() const override { return _wrapped.need_size_for_free(); }
};
};