archive-gh-me/jerryscript
1
0
Fork 0
mirror of https://github.com/jerryscript-project/jerryscript.git synced 2025-12-15 16:29:21 +00:00
Code Issues Projects Releases Wiki Activity

Rework memory statistics to provide useful user information. (#1812)

Browse Source 
Obsolote statistics is also removed.

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com
This commit is contained in:
Zoltan Herczeg 2017-05-16 02:52:12 +02:00 committed by yichoi
parent f5b385ca6c
commit f4fbf0b0b5
18 changed files with 347 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
jerry-core/api/jerry-snapshot.c
View File

@ -373,6 +373,10 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
{
bytecode_p = (ecma_compiled_code_t *) jmem_heap_alloc_block (code_size);
#ifdef JMEM_STATS
jmem_stats_allocate_byte_code_bytes (code_size);
#endif /* JMEM_STATS */
memcpy (bytecode_p, snapshot_data_p + offset, code_size);
}
else
@ -384,6 +388,10 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
bytecode_p = (ecma_compiled_code_t *) jmem_heap_alloc_block (total_size);
#ifdef JMEM_STATS
jmem_stats_allocate_byte_code_bytes (total_size);
#endif /* JMEM_STATS */
memcpy (bytecode_p, snapshot_data_p + offset, code_size);
bytecode_p->size = (uint16_t) (total_size >> JMEM_ALIGNMENT_LOG);

14
jerry-core/api/jerry.c
View File

@ -52,7 +52,6 @@ JERRY_STATIC_ASSERT ((int) ECMA_INIT_EMPTY == (int) JERRY_INIT_EMPTY
&& (int) ECMA_INIT_SHOW_OPCODES == (int) JERRY_INIT_SHOW_OPCODES
&& (int) ECMA_INIT_SHOW_REGEXP_OPCODES == (int) JERRY_INIT_SHOW_REGEXP_OPCODES
&& (int) ECMA_INIT_MEM_STATS == (int) JERRY_INIT_MEM_STATS
&& (int) ECMA_INIT_MEM_STATS_SEPARATE == (int) JERRY_INIT_MEM_STATS_SEPARATE
&& (int) ECMA_INIT_DEBUGGER == (int) JERRY_INIT_DEBUGGER,
ecma_init_flag_t_must_be_equal_to_jerry_init_flag_t);
@ -152,11 +151,6 @@ jerry_init (jerry_init_flag_t flags) /**< combination of Jerry flags */
/* Zero out all members. */
memset (&JERRY_CONTEXT (JERRY_CONTEXT_FIRST_MEMBER), 0, sizeof (jerry_context_t));
if (flags & JERRY_INIT_MEM_STATS_SEPARATE)
{
flags |= JERRY_INIT_MEM_STATS;
}
JERRY_CONTEXT (jerry_init_flags) = flags;
jerry_make_api_available ();
@ -327,14 +321,6 @@ jerry_parse (const jerry_char_t *source_p, /**< script source */
ecma_free_value (parse_status);
#ifdef JMEM_STATS
if (JERRY_CONTEXT (jerry_init_flags) & JERRY_INIT_MEM_STATS_SEPARATE)
{
jmem_stats_print ();
jmem_stats_reset_peak ();
}
#endif /* JMEM_STATS */
is_strict = ((bytecode_data_p->status_flags & CBC_CODE_FLAGS_STRICT_MODE) != 0);
ecma_object_t *lex_env_p = ecma_get_global_environment ();
ecma_object_t *func_obj_p = ecma_op_create_function_object (lex_env_p,

4
jerry-core/debugger/jerry-debugger.c
View File

@ -318,6 +318,10 @@ jerry_debugger_process_message (uint8_t *recv_buffer_p, /**< pointer the the rec
JERRY_CONTEXT (debugger_byte_code_free_tail) = ECMA_NULL_POINTER;
}
#ifdef JMEM_STATS
jmem_stats_free_byte_code_bytes (((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG);
#endif /* JMEM_STATS */
jmem_heap_free_block (byte_code_free_p,
((size_t) byte_code_free_p->size) << JMEM_ALIGNMENT_LOG);
return true;

133
jerry-core/ecma/base/ecma-alloc.c
View File

@ -80,12 +80,37 @@ JERRY_STATIC_ASSERT (sizeof (ecma_extended_object_t) - sizeof (ecma_object_t) <=
ALLOC (ecma_type) \
DEALLOC (ecma_type)
DECLARE_ROUTINES_FOR (object)
DECLARE_ROUTINES_FOR (number)
DECLARE_ROUTINES_FOR (collection_header)
DECLARE_ROUTINES_FOR (collection_chunk)
DECLARE_ROUTINES_FOR (string)
DECLARE_ROUTINES_FOR (getter_setter_pointers)
/**
* Allocate memory for ecma-object
*
* @return pointer to allocated memory
*/
inline ecma_object_t * __attr_always_inline___
ecma_alloc_object (void)
{
#ifdef JMEM_STATS
jmem_stats_allocate_object_bytes (sizeof (ecma_object_t));
#endif /* JMEM_STATS */
return (ecma_object_t *) jmem_pools_alloc (sizeof (ecma_object_t));
} /* ecma_alloc_object */
/**
* Dealloc memory from an ecma-object
*/
inline void __attr_always_inline___
ecma_dealloc_object (ecma_object_t *object_p) /**< object to be freed */
{
#ifdef JMEM_STATS
jmem_stats_free_object_bytes (sizeof (ecma_object_t));
#endif /* JMEM_STATS */
jmem_pools_free (object_p, sizeof (ecma_object_t));
} /* ecma_dealloc_object */
/**
* Allocate memory for extended object
@ -95,6 +120,10 @@ DECLARE_ROUTINES_FOR (getter_setter_pointers)
inline ecma_extended_object_t * __attr_always_inline___
ecma_alloc_extended_object (size_t size) /**< size of object */
{
#ifdef JMEM_STATS
jmem_stats_allocate_object_bytes (size);
#endif /* JMEM_STATS */
return jmem_heap_alloc_block (size);
} /* ecma_alloc_extended_object */
@ -105,9 +134,99 @@ inline void __attr_always_inline___
ecma_dealloc_extended_object (ecma_extended_object_t *ext_object_p, /**< property pair to be freed */
size_t size) /**< size of object */
{
#ifdef JMEM_STATS
jmem_stats_free_object_bytes (size);
#endif /* JMEM_STATS */
jmem_heap_free_block (ext_object_p, size);
} /* ecma_dealloc_extended_object */
/**
* Allocate memory for ecma-string descriptor
*
* @return pointer to allocated memory
*/
inline ecma_string_t * __attr_always_inline___
ecma_alloc_string (void)
{
#ifdef JMEM_STATS
jmem_stats_allocate_string_bytes (sizeof (ecma_string_t));
#endif /* JMEM_STATS */
return (ecma_string_t *) jmem_pools_alloc (sizeof (ecma_string_t));
} /* ecma_alloc_string */
/**
* Dealloc memory from ecma-string descriptor
*/
inline void __attr_always_inline___
ecma_dealloc_string (ecma_string_t *string_p) /**< string to be freed */
{
#ifdef JMEM_STATS
jmem_stats_free_string_bytes (sizeof (ecma_string_t));
#endif /* JMEM_STATS */
jmem_pools_free (string_p, sizeof (ecma_string_t));
} /* ecma_dealloc_string */
/**
* Allocate memory for string with character data
*
* @return pointer to allocated memory
*/
inline ecma_string_t * __attr_always_inline___
ecma_alloc_string_buffer (size_t size) /**< size of string */
{
#ifdef JMEM_STATS
jmem_stats_allocate_string_bytes (size);
#endif /* JMEM_STATS */
return jmem_heap_alloc_block (size);
} /* ecma_alloc_string_buffer */
/**
* Dealloc memory of a string with character data
*/
inline void __attr_always_inline___
ecma_dealloc_string_buffer (ecma_string_t *string_p, /**< string with data */
size_t size) /**< size of string */
{
#ifdef JMEM_STATS
jmem_stats_free_string_bytes (size);
#endif /* JMEM_STATS */
jmem_heap_free_block (string_p, size);
} /* ecma_dealloc_string_buffer */
/**
* Allocate memory for getter-setter pointer pair
*
* @return pointer to allocated memory
*/
inline ecma_getter_setter_pointers_t * __attr_always_inline___
ecma_alloc_getter_setter_pointers (void)
{
#ifdef JMEM_STATS
jmem_stats_allocate_property_bytes (sizeof (ecma_property_pair_t));
#endif /* JMEM_STATS */
return (ecma_getter_setter_pointers_t *) jmem_pools_alloc (sizeof (ecma_getter_setter_pointers_t));
} /* ecma_alloc_getter_setter_pointers */
/**
* Dealloc memory from getter-setter pointer pair
*/
inline void __attr_always_inline___
ecma_dealloc_getter_setter_pointers (ecma_getter_setter_pointers_t *getter_setter_pointers_p) /**< pointer pair
* to be freed */
{
#ifdef JMEM_STATS
jmem_stats_free_property_bytes (sizeof (ecma_property_pair_t));
#endif /* JMEM_STATS */
jmem_pools_free (getter_setter_pointers_p, sizeof (ecma_getter_setter_pointers_t));
} /* ecma_dealloc_getter_setter_pointers */
/**
* Allocate memory for ecma-property pair
*
@ -116,6 +235,10 @@ ecma_dealloc_extended_object (ecma_extended_object_t *ext_object_p, /**< propert
inline ecma_property_pair_t * __attr_always_inline___
ecma_alloc_property_pair (void)
{
#ifdef JMEM_STATS
jmem_stats_allocate_property_bytes (sizeof (ecma_property_pair_t));
#endif /* JMEM_STATS */
return jmem_heap_alloc_block (sizeof (ecma_property_pair_t));
} /* ecma_alloc_property_pair */
@ -125,6 +248,10 @@ ecma_alloc_property_pair (void)
inline void __attr_always_inline___
ecma_dealloc_property_pair (ecma_property_pair_t *property_pair_p) /**< property pair to be freed */
{
#ifdef JMEM_STATS
jmem_stats_free_property_bytes (sizeof (ecma_property_pair_t));
#endif /* JMEM_STATS */
jmem_heap_free_block (property_pair_p, sizeof (ecma_property_pair_t));
} /* ecma_dealloc_property_pair */

36
jerry-core/ecma/base/ecma-alloc.h
View File

@ -37,6 +37,18 @@ ecma_object_t *ecma_alloc_object (void);
*/
void ecma_dealloc_object (ecma_object_t *object_p);
/**
* Allocate memory for extended object
*
* @return pointer to allocated memory
*/
ecma_extended_object_t *ecma_alloc_extended_object (size_t size);
/**
* Dealloc memory of an extended object
*/
void ecma_dealloc_extended_object (ecma_extended_object_t *ext_object_p, size_t size);
/**
* Allocate memory for ecma-number
*
@ -85,6 +97,18 @@ ecma_string_t *ecma_alloc_string (void);
*/
void ecma_dealloc_string (ecma_string_t *string_p);
/**
* Allocate memory for string with character data
*
* @return pointer to allocated memory
*/
ecma_string_t *ecma_alloc_string_buffer (size_t size);
/**
* Dealloc memory of a string with character data
*/
void ecma_dealloc_string_buffer (ecma_string_t *string_p, size_t size);
/**
* Allocate memory for getter-setter pointer pair
*
@ -97,18 +121,6 @@ ecma_getter_setter_pointers_t *ecma_alloc_getter_setter_pointers (void);
*/
void ecma_dealloc_getter_setter_pointers (ecma_getter_setter_pointers_t *getter_setter_pointers_p);
/*
* Allocate memory for extended object
*
* @return pointer to allocated memory
*/
ecma_extended_object_t *ecma_alloc_extended_object (size_t size);
/**
* Dealloc memory of an extended object
*/
void ecma_dealloc_extended_object (ecma_extended_object_t *ext_object_p, size_t size);
/**
* Allocate memory for ecma-property pair
*

1
jerry-core/ecma/base/ecma-globals.h
View File

@ -62,7 +62,6 @@ typedef enum
ECMA_INIT_SHOW_OPCODES = (1u << 0), /**< dump byte-code to log after parse */
ECMA_INIT_SHOW_REGEXP_OPCODES = (1u << 1), /**< dump regexp byte-code to log after compilation */
ECMA_INIT_MEM_STATS = (1u << 2), /**< dump memory statistics */
ECMA_INIT_MEM_STATS_SEPARATE = (1u << 3), /**< dump memory statistics and reset peak values after parse */
ECMA_INIT_DEBUGGER = (1u << 4), /**< enable all features required by debugging */
} ecma_init_flag_t;

18
jerry-core/ecma/base/ecma-helpers-string.c
View File

@ -187,7 +187,7 @@ ecma_new_ecma_string_from_utf8 (const lit_utf8_byte_t *string_p, /**< utf-8 stri
if (likely (string_size <= UINT16_MAX))
{
string_desc_p = jmem_heap_alloc_block (sizeof (ecma_string_t) + string_size);
string_desc_p = ecma_alloc_string_buffer (sizeof (ecma_string_t) + string_size);
string_desc_p->refs_and_container = ECMA_STRING_CONTAINER_HEAP_UTF8_STRING | ECMA_STRING_REF_ONE;
string_desc_p->u.common_uint32_field = 0;
@ -198,7 +198,7 @@ ecma_new_ecma_string_from_utf8 (const lit_utf8_byte_t *string_p, /**< utf-8 stri
}
else
{
string_desc_p = jmem_heap_alloc_block (sizeof (ecma_long_string_t) + string_size);
string_desc_p = ecma_alloc_string_buffer (sizeof (ecma_long_string_t) + string_size);
string_desc_p->refs_and_container = ECMA_STRING_CONTAINER_HEAP_LONG_UTF8_STRING | ECMA_STRING_REF_ONE;
string_desc_p->u.common_uint32_field = 0;
@ -275,7 +275,7 @@ ecma_new_ecma_string_from_utf8_converted_to_cesu8 (const lit_utf8_byte_t *string
if (likely (string_size <= UINT16_MAX))
{
string_desc_p = jmem_heap_alloc_block (sizeof (ecma_string_t) + converted_string_size);
string_desc_p = ecma_alloc_string_buffer (sizeof (ecma_string_t) + converted_string_size);
string_desc_p->refs_and_container = ECMA_STRING_CONTAINER_HEAP_UTF8_STRING | ECMA_STRING_REF_ONE;
string_desc_p->u.common_uint32_field = 0;
@ -286,7 +286,7 @@ ecma_new_ecma_string_from_utf8_converted_to_cesu8 (const lit_utf8_byte_t *string
}
else
{
string_desc_p = jmem_heap_alloc_block (sizeof (ecma_long_string_t) + converted_string_size);
string_desc_p = ecma_alloc_string_buffer (sizeof (ecma_long_string_t) + converted_string_size);
string_desc_p->refs_and_container = ECMA_STRING_CONTAINER_HEAP_LONG_UTF8_STRING | ECMA_STRING_REF_ONE;
string_desc_p->u.common_uint32_field = 0;
@ -428,7 +428,7 @@ ecma_new_ecma_string_from_number (ecma_number_t num) /**< ecma-number */
&& lit_is_ex_utf8_string_magic (str_buf, str_size) == lit_get_magic_string_ex_count ());
#endif /* !JERRY_NDEBUG */
ecma_string_t *string_desc_p = jmem_heap_alloc_block (sizeof (ecma_string_t) + str_size);
ecma_string_t *string_desc_p = ecma_alloc_string_buffer (sizeof (ecma_string_t) + str_size);
string_desc_p->refs_and_container = ECMA_STRING_CONTAINER_HEAP_UTF8_STRING | ECMA_STRING_REF_ONE;
string_desc_p->hash = lit_utf8_string_calc_hash (str_buf, str_size);
@ -671,7 +671,7 @@ ecma_concat_ecma_strings (ecma_string_t *string1_p, /**< first ecma-string */
if (likely (new_size <= UINT16_MAX))
{
string_desc_p = jmem_heap_alloc_block (sizeof (ecma_string_t) + new_size);
string_desc_p = ecma_alloc_string_buffer (sizeof (ecma_string_t) + new_size);
string_desc_p->refs_and_container = ECMA_STRING_CONTAINER_HEAP_UTF8_STRING | ECMA_STRING_REF_ONE;
string_desc_p->u.common_uint32_field = 0;
@ -682,7 +682,7 @@ ecma_concat_ecma_strings (ecma_string_t *string1_p, /**< first ecma-string */
}
else
{
string_desc_p = jmem_heap_alloc_block (sizeof (ecma_long_string_t) + new_size);
string_desc_p = ecma_alloc_string_buffer (sizeof (ecma_long_string_t) + new_size);
string_desc_p->refs_and_container = ECMA_STRING_CONTAINER_HEAP_LONG_UTF8_STRING | ECMA_STRING_REF_ONE;
string_desc_p->u.common_uint32_field = 0;
@ -763,14 +763,14 @@ ecma_deref_ecma_string (ecma_string_t *string_p) /**< ecma-string */
}
#endif /* !JERRY_NDEBUG */
jmem_heap_free_block (string_p, string_p->u.utf8_string.size + sizeof (ecma_string_t));
ecma_dealloc_string_buffer (string_p, string_p->u.utf8_string.size + sizeof (ecma_string_t));
return;
}
case ECMA_STRING_CONTAINER_HEAP_LONG_UTF8_STRING:
{
JERRY_ASSERT (string_p->u.long_utf8_string_size > UINT16_MAX);
jmem_heap_free_block (string_p, string_p->u.long_utf8_string_size + sizeof (ecma_long_string_t));
ecma_dealloc_string_buffer (string_p, string_p->u.long_utf8_string_size + sizeof (ecma_long_string_t));
return;
}
case ECMA_STRING_CONTAINER_UINT32_IN_DESC:

4
jerry-core/ecma/base/ecma-helpers.c
View File

@ -1424,6 +1424,10 @@ ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p) /**< byte code pointer */
return;
}
#endif /* JERRY_DEBUGGER */
#ifdef JMEM_STATS
jmem_stats_free_byte_code_bytes (((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG);
#endif /* JMEM_STATS */
}
else
{

3
jerry-core/ecma/base/ecma-literal-storage.c
View File

@ -13,6 +13,7 @@
* limitations under the License.
*/
#include "ecma-alloc.h"
#include "ecma-literal-storage.h"
#include "ecma-helpers.h"
#include "jcontext.h"
@ -179,7 +180,7 @@ ecma_find_or_create_literal_number (ecma_number_t number_arg) /**< number to be
number_list_p = JMEM_CP_GET_POINTER (ecma_lit_storage_item_t, number_list_p->next_cp);
}
ecma_string_t *string_p = (ecma_string_t *) jmem_pools_alloc (sizeof (ecma_string_t));
ecma_string_t *string_p = ecma_alloc_string ();
string_p->refs_and_container = ECMA_STRING_REF_ONE | ECMA_STRING_LITERAL_NUMBER;
string_p->u.lit_number = num;

2
jerry-core/include/jerryscript-core.h
View File

@ -55,7 +55,7 @@ typedef enum
JERRY_INIT_SHOW_OPCODES = (1u << 0), /**< dump byte-code to log after parse */
JERRY_INIT_SHOW_REGEXP_OPCODES = (1u << 1), /**< dump regexp byte-code to log after compilation */
JERRY_INIT_MEM_STATS = (1u << 2), /**< dump memory statistics */
JERRY_INIT_MEM_STATS_SEPARATE = (1u << 3), /**< dump memory statistics and reset peak values after parse */
JERRY_INIT_MEM_STATS_SEPARATE = (1u << 3), /**< deprecated, an unused placeholder now */
JERRY_INIT_DEBUGGER = (1u << 4), /**< enable all features required by debugging */
} jerry_init_flag_t;

1
jerry-core/jcontext/jcontext.h
View File

@ -106,7 +106,6 @@ typedef struct
#ifdef JMEM_STATS
jmem_heap_stats_t jmem_heap_stats; /**< heap's memory usage statistics */
jmem_pools_stats_t jmem_pools_stats; /**< pools' memory usage statistics */
#endif /* JMEM_STATS */
#ifdef JERRY_VALGRIND_FREYA

2
jerry-core/jmem/jmem-allocator-internal.h
View File

@ -41,8 +41,6 @@ void jmem_run_free_unused_memory_callbacks (jmem_free_unused_memory_severity_t s
* @{
*/
#ifdef JMEM_STATS
void jmem_pools_get_stats (jmem_pools_stats_t *);
void jmem_pools_stats_reset_peak (void);
void jmem_pools_stats_print (void);
#endif /* JMEM_STATS */

128
jerry-core/jmem/jmem-allocator.c
View File

@ -152,16 +152,6 @@ jmem_run_free_unused_memory_callbacks (jmem_free_unused_memory_severity_t severi
} /* jmem_run_free_unused_memory_callbacks */
#ifdef JMEM_STATS
/**
* Reset peak values in memory usage statistics
*/
void
jmem_stats_reset_peak (void)
{
jmem_heap_stats_reset_peak ();
jmem_pools_stats_reset_peak ();
} /* jmem_stats_reset_peak */
/**
* Print memory usage statistics
*/
@ -169,6 +159,122 @@ void
jmem_stats_print (void)
{
jmem_heap_stats_print ();
jmem_pools_stats_print ();
} /* jmem_stats_print */
/**
* Register byte code allocation.
*/
void
jmem_stats_allocate_byte_code_bytes (size_t byte_code_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
heap_stats->byte_code_bytes += byte_code_size;
if (heap_stats->byte_code_bytes >= heap_stats->peak_byte_code_bytes)
{
heap_stats->peak_byte_code_bytes = heap_stats->byte_code_bytes;
}
} /* jmem_stats_allocate_byte_code_bytes */
/**
* Register byte code free.
*/
void
jmem_stats_free_byte_code_bytes (size_t byte_code_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
JERRY_ASSERT (heap_stats->byte_code_bytes >= byte_code_size);
heap_stats->byte_code_bytes -= byte_code_size;
} /* jmem_stats_free_byte_code_bytes */
/**
* Register string allocation.
*/
void
jmem_stats_allocate_string_bytes (size_t string_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
heap_stats->string_bytes += string_size;
if (heap_stats->string_bytes >= heap_stats->peak_string_bytes)
{
heap_stats->peak_string_bytes = heap_stats->string_bytes;
}
} /* jmem_stats_allocate_string_bytes */
/**
* Register string free.
*/
void
jmem_stats_free_string_bytes (size_t string_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
JERRY_ASSERT (heap_stats->string_bytes >= string_size);
heap_stats->string_bytes -= string_size;
} /* jmem_stats_free_string_bytes */
/**
* Register object allocation.
*/
void
jmem_stats_allocate_object_bytes (size_t object_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
heap_stats->object_bytes += object_size;
if (heap_stats->object_bytes >= heap_stats->peak_object_bytes)
{
heap_stats->peak_object_bytes = heap_stats->object_bytes;
}
} /* jmem_stats_allocate_object_bytes */
/**
* Register object free.
*/
void
jmem_stats_free_object_bytes (size_t object_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
JERRY_ASSERT (heap_stats->object_bytes >= object_size);
heap_stats->object_bytes -= object_size;
} /* jmem_stats_free_object_bytes */
/**
* Register property allocation.
*/
void
jmem_stats_allocate_property_bytes (size_t property_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
heap_stats->property_bytes += property_size;
if (heap_stats->property_bytes >= heap_stats->peak_property_bytes)
{
heap_stats->peak_property_bytes = heap_stats->property_bytes;
}
} /* jmem_stats_allocate_property_bytes */
/**
* Register property free.
*/
void
jmem_stats_free_property_bytes (size_t property_size)
{
jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
JERRY_ASSERT (heap_stats->property_bytes >= property_size);
heap_stats->property_bytes -= property_size;
} /* jmem_stats_free_property_bytes */
#endif /* JMEM_STATS */

38
jerry-core/jmem/jmem-heap.c
View File

@ -574,16 +574,6 @@ jmem_heap_get_stats (jmem_heap_stats_t *out_heap_stats_p) /**< [out] heap stats
*out_heap_stats_p = JERRY_CONTEXT (jmem_heap_stats);
} /* jmem_heap_get_stats */
/**
* Reset peak values in memory usage statistics
*/
void
jmem_heap_stats_reset_peak (void)
{
JERRY_CONTEXT (jmem_heap_stats).peak_allocated_bytes = JERRY_CONTEXT (jmem_heap_stats).allocated_bytes;
JERRY_CONTEXT (jmem_heap_stats).peak_waste_bytes = JERRY_CONTEXT (jmem_heap_stats).waste_bytes;
} /* jmem_heap_stats_reset_peak */
/**
* Print heap memory usage statistics
*/
@ -595,18 +585,34 @@ jmem_heap_stats_print (void)
JERRY_DEBUG_MSG ("Heap stats:\n"
" Heap size = %zu bytes\n"
" Allocated = %zu bytes\n"
" Waste = %zu bytes\n"
" Peak allocated = %zu bytes\n"
" Waste = %zu bytes\n"
" Peak waste = %zu bytes\n"
" Allocated byte code data = %zu bytes\n"
" Peak allocated byte code data = %zu bytes\n"
" Allocated string data = %zu bytes\n"
" Peak allocated string data = %zu bytes\n"
" Allocated object data = %zu bytes\n"
" Peak allocated object data = %zu bytes\n"
" Allocated property data = %zu bytes\n"
" Peak allocated property data = %zu bytes\n"
" Skip-ahead ratio = %zu.%04zu\n"
" Average alloc iteration = %zu.%04zu\n"
" Average free iteration = %zu.%04zu\n"
"\n",
heap_stats->size,
heap_stats->allocated_bytes,
heap_stats->waste_bytes,
heap_stats->peak_allocated_bytes,
heap_stats->waste_bytes,
heap_stats->peak_waste_bytes,
heap_stats->byte_code_bytes,
heap_stats->peak_byte_code_bytes,
heap_stats->string_bytes,
heap_stats->peak_string_bytes,
heap_stats->object_bytes,
heap_stats->peak_object_bytes,
heap_stats->property_bytes,
heap_stats->peak_property_bytes,
heap_stats->skip_count / heap_stats->nonskip_count,
heap_stats->skip_count % heap_stats->nonskip_count * 10000 / heap_stats->nonskip_count,
heap_stats->alloc_iter_count / heap_stats->alloc_count,
@ -643,19 +649,11 @@ jmem_heap_stat_alloc (size_t size) /**< Size of allocated block */
{
heap_stats->peak_allocated_bytes = heap_stats->allocated_bytes;
}
if (heap_stats->allocated_bytes > heap_stats->global_peak_allocated_bytes)
{
heap_stats->global_peak_allocated_bytes = heap_stats->allocated_bytes;
}
if (heap_stats->waste_bytes > heap_stats->peak_waste_bytes)
{
heap_stats->peak_waste_bytes = heap_stats->waste_bytes;
}
if (heap_stats->waste_bytes > heap_stats->global_peak_waste_bytes)
{
heap_stats->global_peak_waste_bytes = heap_stats->waste_bytes;
}
} /* jmem_heap_stat_alloc */
/**

138
jerry-core/jmem/jmem-poolman.c
View File

@ -31,24 +31,6 @@
* @{
*/
#ifdef JMEM_STATS
static void jmem_pools_stat_free_pool (void);
static void jmem_pools_stat_new_alloc (void);
static void jmem_pools_stat_reuse (void);
static void jmem_pools_stat_dealloc (void);
# define JMEM_POOLS_STAT_FREE_POOL() jmem_pools_stat_free_pool ()
# define JMEM_POOLS_STAT_NEW_ALLOC() jmem_pools_stat_new_alloc ()
# define JMEM_POOLS_STAT_REUSE() jmem_pools_stat_reuse ()
# define JMEM_POOLS_STAT_DEALLOC() jmem_pools_stat_dealloc ()
#else /* !JMEM_STATS */
# define JMEM_POOLS_STAT_FREE_POOL()
# define JMEM_POOLS_STAT_NEW_ALLOC()
# define JMEM_POOLS_STAT_REUSE()
# define JMEM_POOLS_STAT_DEALLOC()
#endif /* JMEM_STATS */
/*
* Valgrind-related options and headers
*/
@ -107,8 +89,6 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
{
const jmem_pools_chunk_t *const chunk_p = JERRY_CONTEXT (jmem_free_8_byte_chunk_p);
JMEM_POOLS_STAT_REUSE ();
VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
JERRY_CONTEXT (jmem_free_8_byte_chunk_p) = chunk_p->next_p;
@ -119,7 +99,6 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
}
else
{
JMEM_POOLS_STAT_NEW_ALLOC ();
return (void *) jmem_heap_alloc_block (8);
}
}
@ -131,8 +110,6 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
{
const jmem_pools_chunk_t *const chunk_p = JERRY_CONTEXT (jmem_free_16_byte_chunk_p);
JMEM_POOLS_STAT_REUSE ();
VALGRIND_DEFINED_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
JERRY_CONTEXT (jmem_free_16_byte_chunk_p) = chunk_p->next_p;
@ -143,7 +120,6 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
}
else
{
JMEM_POOLS_STAT_NEW_ALLOC ();
return (void *) jmem_heap_alloc_block (16);
}
#else /* !JERRY_CPOINTER_32_BIT */
@ -183,8 +159,6 @@ jmem_pools_free (void *chunk_p, /**< pointer to the chunk */
}
VALGRIND_NOACCESS_SPACE (chunk_to_free_p, size);
JMEM_POOLS_STAT_FREE_POOL ();
} /* jmem_pools_free */
/**
@ -203,7 +177,6 @@ jmem_pools_collect_empty (void)
VALGRIND_NOACCESS_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
jmem_heap_free_block (chunk_p, 8);
JMEM_POOLS_STAT_DEALLOC ();
chunk_p = next_p;
}
@ -218,122 +191,11 @@ jmem_pools_collect_empty (void)
VALGRIND_NOACCESS_SPACE (chunk_p, sizeof (jmem_pools_chunk_t));
jmem_heap_free_block (chunk_p, 16);
JMEM_POOLS_STAT_DEALLOC ();
chunk_p = next_p;
}
#endif /* JERRY_CPOINTER_32_BIT */
} /* jmem_pools_collect_empty */
#ifdef JMEM_STATS
/**
* Get pools memory usage statistics
*/
void
jmem_pools_get_stats (jmem_pools_stats_t *out_pools_stats_p) /**< [out] pools' stats */
{
JERRY_ASSERT (out_pools_stats_p != NULL);
*out_pools_stats_p = JERRY_CONTEXT (jmem_pools_stats);
} /* jmem_pools_get_stats */
/**
* Reset peak values in memory usage statistics
*/
void
jmem_pools_stats_reset_peak (void)
{
JERRY_CONTEXT (jmem_pools_stats).peak_pools_count = JERRY_CONTEXT (jmem_pools_stats.pools_count);
} /* jmem_pools_stats_reset_peak */
/**
* Print pools memory usage statistics
*/
void
jmem_pools_stats_print (void)
{
jmem_pools_stats_t *pools_stats = &JERRY_CONTEXT (jmem_pools_stats);
JERRY_DEBUG_MSG ("Pools stats:\n"
" Pool chunks: %zu\n"
" Peak pool chunks: %zu\n"
" Free chunks: %zu\n"
" Pool reuse ratio: %zu.%04zu\n",
pools_stats->pools_count,
pools_stats->peak_pools_count,
pools_stats->free_chunks,
pools_stats->reused_count / pools_stats->new_alloc_count,
pools_stats->reused_count % pools_stats->new_alloc_count * 10000 / pools_stats->new_alloc_count);
} /* jmem_pools_stats_print */
/**
* Account for allocation of new pool chunk
*/
static void
jmem_pools_stat_new_alloc (void)
{
jmem_pools_stats_t *pools_stats = &JERRY_CONTEXT (jmem_pools_stats);
pools_stats->pools_count++;
pools_stats->new_alloc_count++;
if (pools_stats->pools_count > pools_stats->peak_pools_count)
{
pools_stats->peak_pools_count = pools_stats->pools_count;
}
if (pools_stats->pools_count > pools_stats->global_peak_pools_count)
{
pools_stats->global_peak_pools_count = pools_stats->pools_count;
}
} /* jmem_pools_stat_new_alloc */
/**
* Account for reuse of pool chunk
*/
static void
jmem_pools_stat_reuse (void)
{
jmem_pools_stats_t *pools_stats = &JERRY_CONTEXT (jmem_pools_stats);
pools_stats->pools_count++;
pools_stats->free_chunks--;
pools_stats->reused_count++;
if (pools_stats->pools_count > pools_stats->peak_pools_count)
{
pools_stats->peak_pools_count = pools_stats->pools_count;
}
if (pools_stats->pools_count > pools_stats->global_peak_pools_count)
{
pools_stats->global_peak_pools_count = pools_stats->pools_count;
}
} /* jmem_pools_stat_reuse */
/**
* Account for freeing a chunk
*/
static void
jmem_pools_stat_free_pool (void)
{
jmem_pools_stats_t *pools_stats = &JERRY_CONTEXT (jmem_pools_stats);
JERRY_ASSERT (pools_stats->pools_count > 0);
pools_stats->pools_count--;
pools_stats->free_chunks++;
} /* jmem_pools_stat_free_pool */
/**
* Account for freeing a chunk
*/
static void
jmem_pools_stat_dealloc (void)
{
JERRY_CONTEXT (jmem_pools_stats).free_chunks--;
} /* jmem_pools_stat_dealloc */
#endif /* JMEM_STATS */
#undef VALGRIND_NOACCESS_SPACE
#undef VALGRIND_UNDEFINED_SPACE
#undef VALGRIND_DEFINED_SPACE

50
jerry-core/jmem/jmem.h
View File

@ -119,30 +119,46 @@ void jmem_heap_free_block (void *ptr, const size_t size);
*/
typedef struct
{
size_t size; /**< size */
size_t size; /**< heap total size */
size_t allocated_bytes; /**< currently allocated bytes */
size_t peak_allocated_bytes; /**< peak allocated bytes */
size_t global_peak_allocated_bytes; /**< non-resettable peak allocated bytes */
size_t waste_bytes; /**< bytes waste due to blocks filled partially
* and due to block headers */
size_t peak_waste_bytes; /**< peak bytes waste */
size_t global_peak_waste_bytes; /**< non-resettable peak bytes waste */
size_t waste_bytes; /**< bytes waste due to blocks filled partially */
size_t peak_waste_bytes; /**< peak wasted bytes */
size_t byte_code_bytes; /**< allocated memory for byte code */
size_t peak_byte_code_bytes; /**< peak allocated memory for byte code */
size_t string_bytes; /**< allocated memory for strings */
size_t peak_string_bytes; /**< peak allocated memory for strings */
size_t object_bytes; /**< allocated memory for objects */
size_t peak_object_bytes; /**< peak allocated memory for objects */
size_t property_bytes; /**< allocated memory for properties */
size_t peak_property_bytes; /**< peak allocated memory for properties */
size_t skip_count; /**< Number of skip-aheads during insertion of free block */
size_t nonskip_count; /**< Number of times we could not skip ahead during
* free block insertion */
size_t alloc_count; /**< Number of allocation of new pool chunk */
size_t alloc_count; /**< number of memory allocations */
size_t free_count; /**< number of memory frees */
size_t alloc_iter_count; /**< Number of iterations required for allocations */
size_t free_count; /**< Number of freeing of pool chunk */
size_t free_iter_count; /**< Number of iterations required for inserting free blocks */
} jmem_heap_stats_t;
void jmem_stats_reset_peak (void);
void jmem_stats_print (void);
void jmem_stats_allocate_byte_code_bytes (size_t property_size);
void jmem_stats_free_byte_code_bytes (size_t property_size);
void jmem_stats_allocate_string_bytes (size_t string_size);
void jmem_stats_free_string_bytes (size_t string_size);
void jmem_stats_allocate_object_bytes (size_t object_size);
void jmem_stats_free_object_bytes (size_t string_size);
void jmem_stats_allocate_property_bytes (size_t property_size);
void jmem_stats_free_property_bytes (size_t property_size);
#endif /* JMEM_STATS */
jmem_cpointer_t jmem_compress_pointer (const void *pointer_p) __attr_pure___;
@ -231,20 +247,6 @@ void jmem_run_free_unused_memory_callbacks (jmem_free_unused_memory_severity_t s
* \addtogroup poolman Memory pool manager
* @{
*/
#ifdef JMEM_STATS
/**
* Pools' memory usage statistics
*/
typedef struct
{
size_t pools_count; /**< pools' count */
size_t peak_pools_count; /**< peak pools' count */
size_t global_peak_pools_count; /**< non-resettable peak pools' count */
size_t free_chunks; /**< free chunks count */
size_t new_alloc_count; /**< Number of newly allocated pool chunks */
size_t reused_count; /**< Number of reused pool chunks */
} jmem_pools_stats_t;
#endif /* JMEM_STATS */
void *jmem_pools_alloc (size_t size);
void jmem_pools_free (void *chunk_p, size_t size);

4
jerry-core/parser/js/js-parser.c
View File

@ -1600,6 +1600,10 @@ parser_post_processing (parser_context_t *context_p) /**< context */
compiled_code_p = (ecma_compiled_code_t *) parser_malloc (context_p, total_size);
#ifdef JMEM_STATS
jmem_stats_allocate_byte_code_bytes (total_size);
#endif /* JMEM_STATS */
byte_code_p = (uint8_t *) compiled_code_p;
compiled_code_p->size = (uint16_t) (total_size >> JMEM_ALIGNMENT_LOG);
compiled_code_p->refs = 1;

9
jerry-main/main-unix.c
View File

@ -97,7 +97,6 @@ print_help (const char *name)
" -h, --help\n"
" -v, --version\n"
" --mem-stats\n"
" --mem-stats-separate\n"
" --parse-only\n"
" --show-opcodes\n"
" --show-regexp-opcodes\n"
@ -411,14 +410,6 @@ main (int argc,
flags |= JERRY_INIT_MEM_STATS;
}
}
else if (!strcmp ("--mem-stats-separate", argv[i]))
{
if (check_feature (JERRY_FEATURE_MEM_STATS, argv[i]))
{
jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG);
flags |= JERRY_INIT_MEM_STATS_SEPARATE;
}
}
else if (!strcmp ("--parse-only", argv[i]))
{
is_parse_only = true;