ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-04-12 05:41:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

base: const-correctness of Allocator interface

Browse Source 
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
repos/base-hw/src/core/include/cpu_thread_allocator.h
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;

20
repos/base-hw/src/core/include/kernel/early_translations.h
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; }

12
repos/base-hw/src/core/include/page_slab.h
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; }
};

17
repos/base-linux/src/core/include/platform.h
View File

@ -59,15 +59,14 @@ 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; }
bool need_size_for_free() const override { return true; }
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; }
};
Pseudo_ram_allocator _ram_alloc;

8
repos/base/include/base/allocator.h
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;
};

10
repos/base/include/base/allocator_avl.h
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; }
};

4
repos/base/include/base/allocator_guard.h
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(); }

8
repos/base/include/base/heap.h
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; }
};

8
repos/base/include/base/slab.h
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; }
};

12
repos/base/include/base/sync_allocator.h
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);

4
repos/base/src/base/allocator/allocator_avl.cc
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;

2
repos/base/src/base/allocator/slab.cc
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;

5
repos/base/src/base/heap/sliced_heap.cc
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;
}

46
repos/base/src/core/include/core_mem_alloc.h
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(); }

4
repos/base/src/test/new_delete/main.cc
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);
}

6
repos/dde_linux/src/lib/lxip/lxcc_emul.cc
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; }
/**

6
repos/dde_linux/src/lib/usb/lx_emul.cc
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; }
/**

6
repos/dde_linux/src/lib/wifi/lxcc_emul.cc
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; }
/**

4
repos/dde_rump/include/util/allocator_fap.h
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; }
/**

8
repos/libports/src/lib/libc/malloc.cc
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);

20
repos/os/include/os/packet_allocator.h
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); }
};

4
repos/os/src/lib/dde_kit/memory.cc
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; }
};

4
repos/os/src/test/ram_fs_chunk/main.cc
View File

@ -42,8 +42,8 @@ namespace Genode {
_wrapped.free(addr, size);
}
size_t overhead(size_t size) override { return _wrapped.overhead(size); }
bool need_size_for_free() const override { return _wrapped.need_size_for_free(); }
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(); }
};
};