YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add new coding style rules and fix appeared issues.

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Andrey Shitov a.shitov@samsung.com
This commit is contained in:
Andrey Shitov
2015-05-12 19:17:07 +03:00
parent ca12c16607
commit 9763a93df3
89 changed files with 1152 additions and 626 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/mem/mem-allocator.cpp
+3 -3
View File
@@ -98,16 +98,16 @@ mem_get_base_pointer (void)
uintptr_t
mem_compress_pointer (const void *pointer) /**< pointer to compress */
{
JERRY_ASSERT(pointer != NULL);
JERRY_ASSERT (pointer != NULL);
uintptr_t int_ptr = (uintptr_t) pointer;
JERRY_ASSERT(int_ptr % MEM_ALIGNMENT == 0);
JERRY_ASSERT (int_ptr % MEM_ALIGNMENT == 0);
int_ptr -= mem_get_base_pointer ();
int_ptr >>= MEM_ALIGNMENT_LOG;
JERRY_ASSERT((int_ptr & ~((1u << MEM_HEAP_OFFSET_LOG) - 1)) == 0);
JERRY_ASSERT ((int_ptr & ~((1u << MEM_HEAP_OFFSET_LOG) - 1)) == 0);
JERRY_ASSERT (int_ptr != MEM_CP_NULL);
jerry-core/mem/mem-heap.cpp
+73 -73
View File
@@ -317,7 +317,7 @@ mem_get_next_block_by_direction (const mem_block_header_t* block_p, /**< block *
static size_t
mem_get_block_chunks_count (const mem_block_header_t *block_header_p) /**< block header */
{
JERRY_ASSERT(block_header_p != NULL);
JERRY_ASSERT (block_header_p != NULL);
const mem_block_header_t *next_block_p = mem_get_next_block_by_direction (block_header_p, MEM_DIRECTION_NEXT);
size_t dist_till_block_end;
@@ -331,8 +331,8 @@ mem_get_block_chunks_count (const mem_block_header_t *block_header_p) /**< block
dist_till_block_end = (size_t) ((uint8_t*) next_block_p - (uint8_t*) block_header_p);
}
JERRY_ASSERT(dist_till_block_end <= mem_heap.heap_size);
JERRY_ASSERT(dist_till_block_end % MEM_HEAP_CHUNK_SIZE == 0);
JERRY_ASSERT (dist_till_block_end <= mem_heap.heap_size);
JERRY_ASSERT (dist_till_block_end % MEM_HEAP_CHUNK_SIZE == 0);
return dist_till_block_end / MEM_HEAP_CHUNK_SIZE;
} /* mem_get_block_chunks_count */
@@ -356,7 +356,7 @@ mem_get_block_data_space_size (const mem_block_header_t *block_header_p) /**< bl
static size_t
mem_get_block_chunks_count_from_data_size (size_t block_allocated_size) /**< size of block's allocated area */
{
return JERRY_ALIGNUP(sizeof (mem_block_header_t) + block_allocated_size, MEM_HEAP_CHUNK_SIZE) / MEM_HEAP_CHUNK_SIZE;
return JERRY_ALIGNUP (sizeof (mem_block_header_t) + block_allocated_size, MEM_HEAP_CHUNK_SIZE) / MEM_HEAP_CHUNK_SIZE;
} /* mem_get_block_chunks_count_from_data_size */
/**
@@ -378,17 +378,17 @@ void
mem_heap_init (uint8_t *heap_start, /**< first address of heap space */
size_t heap_size) /**< heap space size */
{
JERRY_ASSERT(heap_start != NULL);
JERRY_ASSERT(heap_size != 0);
JERRY_ASSERT(heap_size % MEM_HEAP_CHUNK_SIZE == 0);
JERRY_ASSERT((uintptr_t) heap_start % MEM_ALIGNMENT == 0);
JERRY_ASSERT(heap_size <= (1u << MEM_HEAP_OFFSET_LOG));
JERRY_ASSERT (heap_start != NULL);
JERRY_ASSERT (heap_size != 0);
JERRY_ASSERT (heap_size % MEM_HEAP_CHUNK_SIZE == 0);
JERRY_ASSERT ((uintptr_t) heap_start % MEM_ALIGNMENT == 0);
JERRY_ASSERT (heap_size <= (1u << MEM_HEAP_OFFSET_LOG));
mem_heap.heap_start = heap_start;
mem_heap.heap_size = heap_size;
mem_heap.limit = CONFIG_MEM_HEAP_DESIRED_LIMIT;
VALGRIND_NOACCESS_SPACE(heap_start, heap_size);
VALGRIND_NOACCESS_SPACE (heap_start, heap_size);
mem_init_block_header (mem_heap.heap_start,
0,
@@ -408,12 +408,12 @@ mem_heap_init (uint8_t *heap_start, /**< first address of heap space */
void
mem_heap_finalize (void)
{
VALGRIND_DEFINED_SPACE(mem_heap.heap_start, mem_heap.heap_size);
VALGRIND_DEFINED_SPACE (mem_heap.heap_start, mem_heap.heap_size);
JERRY_ASSERT(mem_heap.first_block_p == mem_heap.last_block_p);
JERRY_ASSERT (mem_heap.first_block_p == mem_heap.last_block_p);
JERRY_ASSERT (mem_is_block_free (mem_heap.first_block_p));
VALGRIND_NOACCESS_SPACE(mem_heap.heap_start, mem_heap.heap_size);
VALGRIND_NOACCESS_SPACE (mem_heap.heap_start, mem_heap.heap_size);
memset (&mem_heap, 0, sizeof (mem_heap));
} /* mem_heap_finalize */
@@ -430,13 +430,13 @@ mem_init_block_header (uint8_t *first_chunk_p, /**< address of the first
{
mem_block_header_t *block_header_p = (mem_block_header_t*) first_chunk_p;
VALGRIND_UNDEFINED_STRUCT(block_header_p);
VALGRIND_UNDEFINED_STRUCT (block_header_p);
mem_set_block_prev (block_header_p, prev_block_p);
mem_set_block_next (block_header_p, next_block_p);
mem_set_block_allocated_bytes (block_header_p, allocated_bytes);
JERRY_ASSERT(allocated_bytes <= mem_get_block_data_space_size (block_header_p));
JERRY_ASSERT (allocated_bytes <= mem_get_block_data_space_size (block_header_p));
if (block_state == MEM_BLOCK_FREE)
{
@@ -449,7 +449,7 @@ mem_init_block_header (uint8_t *first_chunk_p, /**< address of the first
JERRY_ASSERT (!mem_is_block_free (block_header_p));
}
VALGRIND_NOACCESS_STRUCT(block_header_p);
VALGRIND_NOACCESS_STRUCT (block_header_p);
} /* mem_init_block_header */
/**
@@ -488,7 +488,7 @@ void* mem_heap_alloc_block_internal (size_t size_in_bytes, /**< size
/* searching for appropriate block */
while (block_p != NULL)
{
VALGRIND_DEFINED_STRUCT(block_p);
VALGRIND_DEFINED_STRUCT (block_p);
if (mem_is_block_free (block_p))
{
@@ -504,7 +504,7 @@ void* mem_heap_alloc_block_internal (size_t size_in_bytes, /**< size
mem_block_header_t *next_block_p = mem_get_next_block_by_direction (block_p, direction);
VALGRIND_NOACCESS_STRUCT(block_p);
VALGRIND_NOACCESS_STRUCT (block_p);
block_p = next_block_p;
}
@@ -531,7 +531,7 @@ void* mem_heap_alloc_block_internal (size_t size_in_bytes, /**< size
size_t new_block_size_in_chunks = mem_get_block_chunks_count_from_data_size (size_in_bytes);
size_t found_block_size_in_chunks = mem_get_block_chunks_count (block_p);
JERRY_ASSERT(new_block_size_in_chunks <= found_block_size_in_chunks);
JERRY_ASSERT (new_block_size_in_chunks <= found_block_size_in_chunks);
mem_block_header_t *prev_block_p = mem_get_next_block_by_direction (block_p, MEM_DIRECTION_PREV);
mem_block_header_t *next_block_p = mem_get_next_block_by_direction (block_p, MEM_DIRECTION_NEXT);
@@ -546,11 +546,11 @@ void* mem_heap_alloc_block_internal (size_t size_in_bytes, /**< size
uint8_t *block_end_p = (uint8_t*) block_p + found_block_size_in_chunks * MEM_HEAP_CHUNK_SIZE;
block_p = (mem_block_header_t*) (block_end_p - new_block_size_in_chunks * MEM_HEAP_CHUNK_SIZE);
VALGRIND_DEFINED_STRUCT(prev_block_p);
VALGRIND_DEFINED_STRUCT (prev_block_p);
mem_set_block_next (prev_block_p, block_p);
VALGRIND_NOACCESS_STRUCT(prev_block_p);
VALGRIND_NOACCESS_STRUCT (prev_block_p);
if (next_block_p == NULL)
{
@@ -558,11 +558,11 @@ void* mem_heap_alloc_block_internal (size_t size_in_bytes, /**< size
}
else
{
VALGRIND_DEFINED_STRUCT(next_block_p);
VALGRIND_DEFINED_STRUCT (next_block_p);
mem_set_block_prev (next_block_p, block_p);
VALGRIND_NOACCESS_STRUCT(next_block_p);
VALGRIND_NOACCESS_STRUCT (next_block_p);
}
}
else
@@ -582,12 +582,12 @@ void* mem_heap_alloc_block_internal (size_t size_in_bytes, /**< size
}
else
{
VALGRIND_DEFINED_STRUCT(next_block_p);
VALGRIND_DEFINED_STRUCT (next_block_p);
mem_block_header_t* new_free_block_p = (mem_block_header_t*) new_free_block_first_chunk_p;
mem_set_block_prev (next_block_p, new_free_block_p);
VALGRIND_NOACCESS_STRUCT(next_block_p);
VALGRIND_NOACCESS_STRUCT (next_block_p);
}
next_block_p = new_free_block_p;
@@ -600,19 +600,19 @@ void* mem_heap_alloc_block_internal (size_t size_in_bytes, /**< size
prev_block_p,
next_block_p);
VALGRIND_DEFINED_STRUCT(block_p);
VALGRIND_DEFINED_STRUCT (block_p);
MEM_HEAP_STAT_ALLOC_BLOCK (block_p);
JERRY_ASSERT(mem_get_block_data_space_size (block_p) >= size_in_bytes);
JERRY_ASSERT (mem_get_block_data_space_size (block_p) >= size_in_bytes);
VALGRIND_NOACCESS_STRUCT(block_p);
VALGRIND_NOACCESS_STRUCT (block_p);
/* return data space beginning address */
uint8_t *data_space_p = (uint8_t*) (block_p + 1);
JERRY_ASSERT((uintptr_t) data_space_p % MEM_ALIGNMENT == 0);
JERRY_ASSERT ((uintptr_t) data_space_p % MEM_ALIGNMENT == 0);
VALGRIND_UNDEFINED_SPACE(data_space_p, size_in_bytes);
VALGRIND_UNDEFINED_SPACE (data_space_p, size_in_bytes);
mem_check_heap ();
@@ -683,14 +683,14 @@ mem_heap_free_block (void *ptr) /**< pointer to beginning of data space of the b
uint8_t *uint8_ptr = (uint8_t*) ptr;
/* checking that uint8_ptr points to the heap */
JERRY_ASSERT(uint8_ptr >= mem_heap.heap_start
&& uint8_ptr <= mem_heap.heap_start + mem_heap.heap_size);
JERRY_ASSERT (uint8_ptr >= mem_heap.heap_start
&& uint8_ptr <= mem_heap.heap_start + mem_heap.heap_size);
mem_check_heap ();
mem_block_header_t *block_p = (mem_block_header_t*) uint8_ptr - 1;
VALGRIND_DEFINED_STRUCT(block_p);
VALGRIND_DEFINED_STRUCT (block_p);
mem_block_header_t *prev_block_p = mem_get_next_block_by_direction (block_p, MEM_DIRECTION_PREV);
mem_block_header_t *next_block_p = mem_get_next_block_by_direction (block_p, MEM_DIRECTION_NEXT);
@@ -714,7 +714,7 @@ mem_heap_free_block (void *ptr) /**< pointer to beginning of data space of the b
MEM_HEAP_STAT_FREE_BLOCK (block_p);
VALGRIND_NOACCESS_SPACE(uint8_ptr, block_p->allocated_bytes);
VALGRIND_NOACCESS_SPACE (uint8_ptr, block_p->allocated_bytes);
JERRY_ASSERT (!mem_is_block_free (block_p));
@@ -723,7 +723,7 @@ mem_heap_free_block (void *ptr) /**< pointer to beginning of data space of the b
if (next_block_p != NULL)
{
VALGRIND_DEFINED_STRUCT(next_block_p);
VALGRIND_DEFINED_STRUCT (next_block_p);
if (mem_is_block_free (next_block_p))
{
@@ -732,11 +732,11 @@ mem_heap_free_block (void *ptr) /**< pointer to beginning of data space of the b
mem_block_header_t *next_next_block_p = mem_get_next_block_by_direction (next_block_p, MEM_DIRECTION_NEXT);
VALGRIND_NOACCESS_STRUCT(next_block_p);
VALGRIND_NOACCESS_STRUCT (next_block_p);
next_block_p = next_next_block_p;
VALGRIND_DEFINED_STRUCT(next_block_p);
VALGRIND_DEFINED_STRUCT (next_block_p);
mem_set_block_next (block_p, next_block_p);
if (next_block_p != NULL)
@@ -749,12 +749,12 @@ mem_heap_free_block (void *ptr) /**< pointer to beginning of data space of the b
}
}
VALGRIND_NOACCESS_STRUCT(next_block_p);
VALGRIND_NOACCESS_STRUCT (next_block_p);
}
if (prev_block_p != NULL)
{
VALGRIND_DEFINED_STRUCT(prev_block_p);
VALGRIND_DEFINED_STRUCT (prev_block_p);
if (mem_is_block_free (prev_block_p))
{
@@ -764,12 +764,12 @@ mem_heap_free_block (void *ptr) /**< pointer to beginning of data space of the b
mem_set_block_next (prev_block_p, next_block_p);
if (next_block_p != NULL)
{
VALGRIND_DEFINED_STRUCT(next_block_p);
VALGRIND_DEFINED_STRUCT (next_block_p);
mem_block_header_t* prev_block_p = mem_get_next_block_by_direction (block_p, MEM_DIRECTION_PREV);
mem_set_block_prev (next_block_p, prev_block_p);
VALGRIND_NOACCESS_STRUCT(next_block_p);
VALGRIND_NOACCESS_STRUCT (next_block_p);
}
else
{
@@ -777,10 +777,10 @@ mem_heap_free_block (void *ptr) /**< pointer to beginning of data space of the b
}
}
VALGRIND_NOACCESS_STRUCT(prev_block_p);
VALGRIND_NOACCESS_STRUCT (prev_block_p);
}
VALGRIND_NOACCESS_STRUCT(block_p);
VALGRIND_NOACCESS_STRUCT (block_p);
mem_check_heap ();
} /* mem_heap_free_block */
@@ -853,8 +853,8 @@ size_t __attr_pure___
mem_heap_recommend_allocation_size (size_t minimum_allocation_size) /**< minimum allocation size */
{
size_t minimum_allocation_size_with_block_header = minimum_allocation_size + sizeof (mem_block_header_t);
size_t heap_chunk_aligned_allocation_size = JERRY_ALIGNUP(minimum_allocation_size_with_block_header,
MEM_HEAP_CHUNK_SIZE);
size_t heap_chunk_aligned_allocation_size = JERRY_ALIGNUP (minimum_allocation_size_with_block_header,
MEM_HEAP_CHUNK_SIZE);
return heap_chunk_aligned_allocation_size - sizeof (mem_block_header_t);
} /* mem_heap_recommend_allocation_size */
@@ -870,7 +870,7 @@ mem_heap_print (bool dump_block_headers, /**< print block headers */
{
mem_check_heap ();
JERRY_ASSERT(!dump_block_data || dump_block_headers);
JERRY_ASSERT (!dump_block_data || dump_block_headers);
if (dump_block_headers)
{
@@ -884,7 +884,7 @@ mem_heap_print (bool dump_block_headers, /**< print block headers */
block_p != NULL;
block_p = next_block_p)
{
VALGRIND_DEFINED_STRUCT(block_p);
VALGRIND_DEFINED_STRUCT (block_p);
printf ("Block (%p): state=%s, size in chunks=%lu, previous block->%p next block->%p\n",
(void*) block_p,
@@ -907,7 +907,7 @@ mem_heap_print (bool dump_block_headers, /**< print block headers */
next_block_p = mem_get_next_block_by_direction (block_p, MEM_DIRECTION_NEXT);
VALGRIND_NOACCESS_STRUCT(block_p);
VALGRIND_NOACCESS_STRUCT (block_p);
}
}
@@ -952,8 +952,8 @@ static void
mem_check_heap (void)
{
#ifndef JERRY_NDEBUG
JERRY_ASSERT((uint8_t*) mem_heap.first_block_p == mem_heap.heap_start);
JERRY_ASSERT(mem_heap.heap_size % MEM_HEAP_CHUNK_SIZE == 0);
JERRY_ASSERT ((uint8_t*) mem_heap.first_block_p == mem_heap.heap_start);
JERRY_ASSERT (mem_heap.heap_size % MEM_HEAP_CHUNK_SIZE == 0);
bool is_last_block_was_met = false;
size_t chunk_sizes_sum = 0;
@@ -963,7 +963,7 @@ mem_check_heap (void)
block_p != NULL;
block_p = next_block_p)
{
VALGRIND_DEFINED_STRUCT(block_p);
VALGRIND_DEFINED_STRUCT (block_p);
chunk_sizes_sum += mem_get_block_chunks_count (block_p);
@@ -978,19 +978,19 @@ mem_check_heap (void)
{
is_last_block_was_met = true;
JERRY_ASSERT(next_block_p == NULL);
JERRY_ASSERT (next_block_p == NULL);
}
else
{
JERRY_ASSERT(next_block_p != NULL);
JERRY_ASSERT (next_block_p != NULL);
}
VALGRIND_NOACCESS_STRUCT(block_p);
VALGRIND_NOACCESS_STRUCT (block_p);
}
JERRY_ASSERT(chunk_sizes_sum * MEM_HEAP_CHUNK_SIZE == mem_heap.heap_size);
JERRY_ASSERT(allocated_sum == mem_heap.allocated_bytes);
JERRY_ASSERT(is_last_block_was_met);
JERRY_ASSERT (chunk_sizes_sum * MEM_HEAP_CHUNK_SIZE == mem_heap.heap_size);
JERRY_ASSERT (allocated_sum == mem_heap.allocated_bytes);
JERRY_ASSERT (is_last_block_was_met);
bool is_first_block_was_met = false;
chunk_sizes_sum = 0;
@@ -999,7 +999,7 @@ mem_check_heap (void)
block_p != NULL;
block_p = prev_block_p)
{
VALGRIND_DEFINED_STRUCT(block_p);
VALGRIND_DEFINED_STRUCT (block_p);
chunk_sizes_sum += mem_get_block_chunks_count (block_p);
@@ -1009,18 +1009,18 @@ mem_check_heap (void)
{
is_first_block_was_met = true;
JERRY_ASSERT(prev_block_p == NULL);
JERRY_ASSERT (prev_block_p == NULL);
}
else
{
JERRY_ASSERT(prev_block_p != NULL);
JERRY_ASSERT (prev_block_p != NULL);
}
VALGRIND_NOACCESS_STRUCT(block_p);
VALGRIND_NOACCESS_STRUCT (block_p);
}
JERRY_ASSERT(chunk_sizes_sum * MEM_HEAP_CHUNK_SIZE == mem_heap.heap_size);
JERRY_ASSERT(is_first_block_was_met);
JERRY_ASSERT (chunk_sizes_sum * MEM_HEAP_CHUNK_SIZE == mem_heap.heap_size);
JERRY_ASSERT (is_first_block_was_met);
#endif /* !JERRY_NDEBUG */
} /* mem_check_heap */
@@ -1111,9 +1111,9 @@ mem_heap_stat_alloc_block (mem_block_header_t *block_header_p) /**< allocated bl
mem_heap_stats.global_peak_waste_bytes = mem_heap_stats.waste_bytes;
}
JERRY_ASSERT(mem_heap_stats.allocated_blocks <= mem_heap_stats.blocks);
JERRY_ASSERT(mem_heap_stats.allocated_bytes <= mem_heap_stats.size);
JERRY_ASSERT(mem_heap_stats.allocated_chunks <= mem_heap_stats.size / MEM_HEAP_CHUNK_SIZE);
JERRY_ASSERT (mem_heap_stats.allocated_blocks <= mem_heap_stats.blocks);
JERRY_ASSERT (mem_heap_stats.allocated_bytes <= mem_heap_stats.size);
JERRY_ASSERT (mem_heap_stats.allocated_chunks <= mem_heap_stats.size / MEM_HEAP_CHUNK_SIZE);
} /* mem_heap_stat_alloc_block */
/**
@@ -1128,14 +1128,14 @@ mem_heap_stat_free_block (mem_block_header_t *block_header_p) /**< block to be f
const size_t bytes = block_header_p->allocated_bytes;
const size_t waste_bytes = chunks * MEM_HEAP_CHUNK_SIZE - bytes;
JERRY_ASSERT(mem_heap_stats.allocated_blocks <= mem_heap_stats.blocks);
JERRY_ASSERT(mem_heap_stats.allocated_bytes <= mem_heap_stats.size);
JERRY_ASSERT(mem_heap_stats.allocated_chunks <= mem_heap_stats.size / MEM_HEAP_CHUNK_SIZE);
JERRY_ASSERT (mem_heap_stats.allocated_blocks <= mem_heap_stats.blocks);
JERRY_ASSERT (mem_heap_stats.allocated_bytes <= mem_heap_stats.size);
JERRY_ASSERT (mem_heap_stats.allocated_chunks <= mem_heap_stats.size / MEM_HEAP_CHUNK_SIZE);
JERRY_ASSERT(mem_heap_stats.allocated_blocks >= 1);
JERRY_ASSERT(mem_heap_stats.allocated_chunks >= chunks);
JERRY_ASSERT(mem_heap_stats.allocated_bytes >= bytes);
JERRY_ASSERT(mem_heap_stats.waste_bytes >= waste_bytes);
JERRY_ASSERT (mem_heap_stats.allocated_blocks >= 1);
JERRY_ASSERT (mem_heap_stats.allocated_chunks >= chunks);
JERRY_ASSERT (mem_heap_stats.allocated_bytes >= bytes);
JERRY_ASSERT (mem_heap_stats.waste_bytes >= waste_bytes);
mem_heap_stats.allocated_blocks--;
mem_heap_stats.allocated_chunks -= chunks;
jerry-core/mem/mem-pool.cpp
+17 -17
View File
@@ -65,8 +65,8 @@ mem_pool_is_chunk_inside (mem_pool_state_t *pool_p, /**< pool */
{
if (chunk_p >= (uint8_t*) pool_p && chunk_p < (uint8_t*) pool_p + MEM_POOL_SIZE)
{
JERRY_ASSERT (chunk_p >= MEM_POOL_SPACE_START(pool_p)
&& chunk_p <= MEM_POOL_SPACE_START(pool_p) + MEM_POOL_CHUNKS_NUMBER * MEM_POOL_CHUNK_SIZE);
JERRY_ASSERT (chunk_p >= MEM_POOL_SPACE_START (pool_p)
&& chunk_p <= MEM_POOL_SPACE_START (pool_p) + MEM_POOL_CHUNKS_NUMBER * MEM_POOL_CHUNK_SIZE);
return true;
}
@@ -84,12 +84,12 @@ void
mem_pool_init (mem_pool_state_t *pool_p, /**< pool */
size_t pool_size) /**< pool size */
{
JERRY_ASSERT(pool_p != NULL);
JERRY_ASSERT((size_t)MEM_POOL_SPACE_START(pool_p) % MEM_ALIGNMENT == 0);
JERRY_ASSERT (pool_p != NULL);
JERRY_ASSERT ((size_t)MEM_POOL_SPACE_START (pool_p) % MEM_ALIGNMENT == 0);
JERRY_STATIC_ASSERT(MEM_POOL_CHUNK_SIZE % MEM_ALIGNMENT == 0);
JERRY_STATIC_ASSERT(MEM_POOL_MAX_CHUNKS_NUMBER_LOG <= sizeof (mem_pool_chunk_index_t) * JERRY_BITSINBYTE);
JERRY_ASSERT(sizeof (mem_pool_chunk_index_t) <= MEM_POOL_CHUNK_SIZE);
JERRY_STATIC_ASSERT (MEM_POOL_CHUNK_SIZE % MEM_ALIGNMENT == 0);
JERRY_STATIC_ASSERT (MEM_POOL_MAX_CHUNKS_NUMBER_LOG <= sizeof (mem_pool_chunk_index_t) * JERRY_BITSINBYTE);
JERRY_ASSERT (sizeof (mem_pool_chunk_index_t) <= MEM_POOL_CHUNK_SIZE);
JERRY_ASSERT (MEM_POOL_SIZE == sizeof (mem_pool_state_t) + MEM_POOL_CHUNKS_NUMBER * MEM_POOL_CHUNK_SIZE);
JERRY_ASSERT (MEM_POOL_CHUNKS_NUMBER >= CONFIG_MEM_LEAST_CHUNK_NUMBER_IN_POOL);
@@ -111,8 +111,8 @@ mem_pool_init (mem_pool_state_t *pool_p, /**< pool */
chunk_index < MEM_POOL_CHUNKS_NUMBER;
chunk_index++)
{
mem_pool_chunk_index_t *next_free_chunk_index_p = (mem_pool_chunk_index_t*) MEM_POOL_CHUNK_ADDRESS(pool_p,
chunk_index);
mem_pool_chunk_index_t *next_free_chunk_index_p = (mem_pool_chunk_index_t*) MEM_POOL_CHUNK_ADDRESS (pool_p,
chunk_index);
*next_free_chunk_index_p = (mem_pool_chunk_index_t) (chunk_index + 1u);
@@ -134,7 +134,7 @@ mem_pool_alloc_chunk (mem_pool_state_t *pool_p) /**< pool */
JERRY_ASSERT (pool_p->first_free_chunk < MEM_POOL_CHUNKS_NUMBER);
mem_pool_chunk_index_t chunk_index = pool_p->first_free_chunk;
uint8_t *chunk_p = MEM_POOL_CHUNK_ADDRESS(pool_p, chunk_index);
uint8_t *chunk_p = MEM_POOL_CHUNK_ADDRESS (pool_p, chunk_index);
VALGRIND_DEFINED_SPACE (chunk_p, MEM_POOL_CHUNK_SIZE);
@@ -156,13 +156,13 @@ void
mem_pool_free_chunk (mem_pool_state_t *pool_p, /**< pool */
uint8_t *chunk_p) /**< chunk pointer */
{
JERRY_ASSERT(pool_p->free_chunks_number < MEM_POOL_CHUNKS_NUMBER);
JERRY_ASSERT(mem_pool_is_chunk_inside (pool_p, chunk_p));
JERRY_ASSERT(((uintptr_t) chunk_p - (uintptr_t) MEM_POOL_SPACE_START(pool_p)) % MEM_POOL_CHUNK_SIZE == 0);
JERRY_ASSERT (pool_p->free_chunks_number < MEM_POOL_CHUNKS_NUMBER);
JERRY_ASSERT (mem_pool_is_chunk_inside (pool_p, chunk_p));
JERRY_ASSERT (((uintptr_t) chunk_p - (uintptr_t) MEM_POOL_SPACE_START (pool_p)) % MEM_POOL_CHUNK_SIZE == 0);
mem_check_pool (pool_p);
const size_t chunk_byte_offset = (size_t) (chunk_p - MEM_POOL_SPACE_START(pool_p));
const size_t chunk_byte_offset = (size_t) (chunk_p - MEM_POOL_SPACE_START (pool_p));
const mem_pool_chunk_index_t chunk_index = (mem_pool_chunk_index_t) (chunk_byte_offset / MEM_POOL_CHUNK_SIZE);
mem_pool_chunk_index_t *next_free_chunk_index_p = (mem_pool_chunk_index_t*) chunk_p;
@@ -184,14 +184,14 @@ static void
mem_check_pool (mem_pool_state_t __attr_unused___ *pool_p) /**< pool (unused #ifdef JERRY_NDEBUG) */
{
#ifndef JERRY_NDEBUG
JERRY_ASSERT(pool_p->free_chunks_number <= MEM_POOL_CHUNKS_NUMBER);
JERRY_ASSERT (pool_p->free_chunks_number <= MEM_POOL_CHUNKS_NUMBER);
size_t met_free_chunks_number = 0;
mem_pool_chunk_index_t chunk_index = pool_p->first_free_chunk;
while (chunk_index != MEM_POOL_CHUNKS_NUMBER)
{
uint8_t *chunk_p = MEM_POOL_CHUNK_ADDRESS(pool_p, chunk_index);
uint8_t *chunk_p = MEM_POOL_CHUNK_ADDRESS (pool_p, chunk_index);
mem_pool_chunk_index_t *next_free_chunk_index_p = (mem_pool_chunk_index_t*) chunk_p;
met_free_chunks_number++;
@@ -203,7 +203,7 @@ mem_check_pool (mem_pool_state_t __attr_unused___ *pool_p) /**< pool (unused #if
VALGRIND_NOACCESS_SPACE (next_free_chunk_index_p, MEM_POOL_CHUNK_SIZE);
}
JERRY_ASSERT(met_free_chunks_number == pool_p->free_chunks_number);
JERRY_ASSERT (met_free_chunks_number == pool_p->free_chunks_number);
#endif /* !JERRY_NDEBUG */
} /* mem_check_pool */
jerry-core/mem/mem-poolman.cpp
+6 -6
View File
@@ -86,8 +86,8 @@ mem_pools_init (void)
void
mem_pools_finalize (void)
{
JERRY_ASSERT(mem_pools == NULL);
JERRY_ASSERT(mem_free_chunks_number == 0);
JERRY_ASSERT (mem_pools == NULL);
JERRY_ASSERT (mem_free_chunks_number == 0);
} /* mem_pools_finalize */
/**
@@ -234,7 +234,7 @@ mem_pools_free (uint8_t *chunk_p) /**< pointer to the chunk */
void
mem_pools_get_stats (mem_pools_stats_t *out_pools_stats_p) /**< out: pools' stats */
{
JERRY_ASSERT(out_pools_stats_p != NULL);
JERRY_ASSERT (out_pools_stats_p != NULL);
*out_pools_stats_p = mem_pools_stats;
} /* mem_pools_get_stats */
@@ -283,7 +283,7 @@ mem_pools_stat_alloc_pool (void)
static void
mem_pools_stat_free_pool (void)
{
JERRY_ASSERT(mem_pools_stats.pools_count > 0);
JERRY_ASSERT (mem_pools_stats.pools_count > 0);
mem_pools_stats.pools_count--;
mem_pools_stats.free_chunks = mem_free_chunks_number;
@@ -295,7 +295,7 @@ mem_pools_stat_free_pool (void)
static void
mem_pools_stat_alloc_chunk (void)
{
JERRY_ASSERT(mem_pools_stats.free_chunks > 0);
JERRY_ASSERT (mem_pools_stats.free_chunks > 0);
mem_pools_stats.allocated_chunks++;
mem_pools_stats.free_chunks--;
@@ -316,7 +316,7 @@ mem_pools_stat_alloc_chunk (void)
static void
mem_pools_stat_free_chunk (void)
{
JERRY_ASSERT(mem_pools_stats.allocated_chunks > 0);
JERRY_ASSERT (mem_pools_stats.allocated_chunks > 0);
mem_pools_stats.allocated_chunks--;
mem_pools_stats.free_chunks++;