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

New Allocator and improved String handling.

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Dániel Bátyai dbatyai@inf.u-szeged.hu
This commit is contained in:
Dániel Bátyai 2016-02-11 14:46:08 +01:00
parent 3d6339bbf4
commit d47c36f1b4
45 changed files with 1383 additions and 4288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -213,6 +213,9 @@ project (Jerry C ASM)
# Compiler / Linker flags
set(COMPILE_FLAGS_JERRY "-fno-builtin")
if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
set(COMPILE_FLAGS_JERRY "${COMPILE_FLAGS_JERRY} -DMEM_HEAP_PTR_64")
endif()
if(NOT ("${PLATFORM}" STREQUAL "DARWIN"))
set(LINKER_FLAGS_COMMON "-Wl,-z,noexecstack")
endif()

10
jerry-core/config.h
View File

@ -1,4 +1,5 @@
/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -47,10 +48,15 @@
# error "Currently, maximum 256 kilobytes heap size is supported"
#endif /* !CONFIG_MEM_HEAP_AREA_SIZE */
/**
* Max heap usage limit
*/
#define CONFIG_MEM_HEAP_MAX_LIMIT 8192
/**
* Desired limit of heap usage
*/
#define CONFIG_MEM_HEAP_DESIRED_LIMIT (CONFIG_MEM_HEAP_AREA_SIZE / 32)
#define CONFIG_MEM_HEAP_DESIRED_LIMIT (JERRY_MIN (CONFIG_MEM_HEAP_AREA_SIZE / 32, CONFIG_MEM_HEAP_MAX_LIMIT))
/**
* Log2 of maximum possible offset in the heap
@ -80,7 +86,7 @@
* Also the option affects size of ECMA Object Model's data types.
* In any case size of any of the types should not exceed CONFIG_MEM_POOL_CHUNK_SIZE.
*/
#define CONFIG_ECMA_REFERENCE_COUNTER_WIDTH (10)
#define CONFIG_ECMA_REFERENCE_COUNTER_WIDTH (12)
#define CONFIG_ECMA_REFERENCE_COUNTER_LIMIT ((1u << CONFIG_ECMA_REFERENCE_COUNTER_WIDTH) - 1u)

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

@ -25,7 +25,6 @@
#include "config.h"
#include "jrt.h"
#include "lit-globals.h"
#include "lit-magic-strings.h"
#include "mem-allocator.h"
@ -384,7 +383,7 @@ typedef struct ecma_object_t
*/
#define ECMA_OBJECT_OBJ_TYPE_POS (ECMA_OBJECT_OBJ_EXTENSIBLE_POS + \
ECMA_OBJECT_OBJ_EXTENSIBLE_WIDTH)
#define ECMA_OBJECT_OBJ_TYPE_WIDTH (4)
#define ECMA_OBJECT_OBJ_TYPE_WIDTH (3)
/**
* Compressed pointer to prototype object (ecma_object_t)
@ -721,7 +720,7 @@ typedef struct ecma_string_t
union
{
/** Index of string in literal table */
lit_cpointer_t lit_cp;
mem_cpointer_t lit_cp;
/** Compressed pointer to an ecma_collection_header_t */
__extension__ mem_cpointer_t collection_cp : ECMA_POINTER_FIELD_WIDTH;

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

@ -31,7 +31,7 @@
#include "lit-char-helpers.h"
#include "lit-literal.h"
#include "lit-magic-strings.h"
#include "rcs-records.h"
#include "lit-literal-storage.h"
#include "vm.h"
/**
@ -46,6 +46,15 @@ JERRY_STATIC_ASSERT ((int32_t) ECMA_STRING_MAX_CONCATENATION_LENGTH ==
ECMA_STRING_MAX_CONCATENATION_LENGTH,
ECMA_STRING_MAX_CONCATENATION_LENGTH_should_be_representable_with_int32_t);
/**
* String header
*/
typedef struct
{
uint16_t size; /* Size of string in bytes */
uint16_t length; /* Number of characters in the string */
} ecma_string_heap_header_t;
static void
ecma_init_ecma_string_from_lit_cp (ecma_string_t *string_p,
lit_cpointer_t lit_index);
@ -56,264 +65,6 @@ ecma_init_ecma_string_from_magic_string_id (ecma_string_t *string_p,
static void
ecma_init_ecma_string_from_magic_string_ex_id (ecma_string_t *string_p,
lit_magic_string_ex_id_t magic_string_ex_id);
/**
* Allocate a collection of ecma-chars.
*
* @return pointer to the collection's header
*/
static ecma_collection_header_t *
ecma_new_chars_collection (const lit_utf8_byte_t chars_buffer[], /**< utf-8 chars */
lit_utf8_size_t chars_size) /**< size of buffer with chars */
{
JERRY_ASSERT (chars_buffer != NULL);
JERRY_ASSERT (chars_size > 0);
ecma_collection_header_t *collection_p = ecma_alloc_collection_header ();
collection_p->unit_number = chars_size;
mem_cpointer_t *next_chunk_cp_p = &collection_p->first_chunk_cp;
lit_utf8_byte_t *cur_char_buf_iter_p = NULL;
lit_utf8_byte_t *cur_char_buf_end_p = NULL;
for (lit_utf8_size_t byte_index = 0;
byte_index < chars_size;
byte_index++)
{
if (cur_char_buf_iter_p == cur_char_buf_end_p)
{
ecma_collection_chunk_t *chunk_p = ecma_alloc_collection_chunk ();
ECMA_SET_NON_NULL_POINTER (*next_chunk_cp_p, chunk_p);
next_chunk_cp_p = &chunk_p->next_chunk_cp;
cur_char_buf_iter_p = (lit_utf8_byte_t *) chunk_p->data;
cur_char_buf_end_p = cur_char_buf_iter_p + sizeof (chunk_p->data);
}
JERRY_ASSERT (cur_char_buf_iter_p + 1 <= cur_char_buf_end_p);
*cur_char_buf_iter_p++ = chars_buffer[byte_index];
}
*next_chunk_cp_p = ECMA_NULL_POINTER;
return collection_p;
} /* ecma_new_chars_collection */
/**
* Get length of a collection of ecma-chars
*
* NOTE:
* While chars collection holds a string in utf-8 encoding, this function acts as if the string was encoded in
* UTF-16 and returns number of 16-bit characters (code units) required for string representation in this format.
*
* @return number of UTF-16 code units in a collecton
*/
static ecma_length_t
ecma_get_chars_collection_length (const ecma_collection_header_t *header_p) /**< collection's header */
{
JERRY_ASSERT (header_p != NULL);
const ecma_length_t chars_number = header_p->unit_number;
const lit_utf8_byte_t *cur_char_buf_iter_p = NULL;
const lit_utf8_byte_t *cur_char_buf_end_p = NULL;
mem_cpointer_t next_chunk_cp = header_p->first_chunk_cp;
lit_utf8_size_t skip_bytes = 0;
ecma_length_t length = 0;
ecma_length_t char_index;
for (char_index = 0;
char_index < chars_number;
char_index++)
{
if (cur_char_buf_iter_p == cur_char_buf_end_p)
{
const ecma_collection_chunk_t *chunk_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_chunk_t, next_chunk_cp);
cur_char_buf_iter_p = (lit_utf8_byte_t *) chunk_p->data;
cur_char_buf_end_p = cur_char_buf_iter_p + sizeof (chunk_p->data);
next_chunk_cp = chunk_p->next_chunk_cp;
}
JERRY_ASSERT (cur_char_buf_iter_p + 1 <= cur_char_buf_end_p);
if (skip_bytes == 0)
{
skip_bytes = lit_get_unicode_char_size_by_utf8_first_byte (*cur_char_buf_iter_p);
length++;
skip_bytes--;
}
else
{
skip_bytes--;
}
cur_char_buf_iter_p++;
}
JERRY_ASSERT (char_index == chars_number);
return length;
} /* ecma_get_chars_collection_length */
/**
* Compare two collection of ecma-chars.
*
* @return true - if collections are equal,
* false - otherwise.
*/
static bool
ecma_compare_chars_collection (const ecma_collection_header_t *header1_p, /**< first collection's header */
const ecma_collection_header_t *header2_p) /**< second collection's header */
{
JERRY_ASSERT (header1_p != NULL && header2_p != NULL);
if (header1_p->unit_number != header2_p->unit_number)
{
return false;
}
const ecma_length_t chars_number = header1_p->unit_number;
const lit_utf8_byte_t *cur_char_buf1_iter_p = NULL;
const lit_utf8_byte_t *cur_char_buf1_end_p = NULL;
const lit_utf8_byte_t *cur_char_buf2_iter_p = NULL;
const lit_utf8_byte_t *cur_char_buf2_end_p = NULL;
mem_cpointer_t next_chunk1_cp = header1_p->first_chunk_cp;
mem_cpointer_t next_chunk2_cp = header2_p->first_chunk_cp;
for (ecma_length_t char_index = 0;
char_index < chars_number;
char_index++)
{
if (cur_char_buf1_iter_p == cur_char_buf1_end_p)
{
JERRY_ASSERT (cur_char_buf2_iter_p == cur_char_buf2_end_p);
const ecma_collection_chunk_t *chunk1_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_chunk_t, next_chunk1_cp);
const ecma_collection_chunk_t *chunk2_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_chunk_t, next_chunk2_cp);
cur_char_buf1_iter_p = (lit_utf8_byte_t *) chunk1_p->data;
cur_char_buf1_end_p = cur_char_buf1_iter_p + sizeof (chunk1_p->data);
cur_char_buf2_iter_p = (lit_utf8_byte_t *) chunk2_p->data;
cur_char_buf2_end_p = cur_char_buf2_iter_p + sizeof (chunk2_p->data);
next_chunk1_cp = chunk1_p->next_chunk_cp;
next_chunk2_cp = chunk2_p->next_chunk_cp;
}
JERRY_ASSERT (cur_char_buf1_iter_p + 1 <= cur_char_buf1_end_p);
JERRY_ASSERT (cur_char_buf2_iter_p + 1 <= cur_char_buf2_end_p);
if (*cur_char_buf1_iter_p++ != *cur_char_buf2_iter_p++)
{
return false;
}
}
return true;
} /* ecma_compare_chars_collection */
/**
* Copy the collection of ecma-chars.
*
* @return pointer to collection copy
*/
static ecma_collection_header_t *
ecma_copy_chars_collection (const ecma_collection_header_t *collection_p) /**< collection's header */
{
JERRY_ASSERT (collection_p != NULL);
ecma_collection_header_t *new_header_p = ecma_alloc_collection_header ();
*new_header_p = *collection_p;
mem_cpointer_t *next_chunk_cp_p = &new_header_p->first_chunk_cp;
ecma_collection_chunk_t *chunk_p = ECMA_GET_POINTER (ecma_collection_chunk_t,
collection_p->first_chunk_cp);
while (chunk_p != NULL)
{
ecma_collection_chunk_t *new_chunk_p = ecma_alloc_collection_chunk ();
*new_chunk_p = *chunk_p;
ECMA_SET_NON_NULL_POINTER (*next_chunk_cp_p, new_chunk_p);
next_chunk_cp_p = &new_chunk_p->next_chunk_cp;
chunk_p = ECMA_GET_POINTER (ecma_collection_chunk_t,
chunk_p->next_chunk_cp);
}
*next_chunk_cp_p = ECMA_NULL_POINTER;
return new_header_p;
} /* ecma_copy_chars_collection */
/**
* Copy characters of the collection to buffer
*/
static void
ecma_copy_chars_collection_to_buffer (const ecma_collection_header_t *collection_p, /**< collection header */
lit_utf8_byte_t chars_buffer[], /**< buffer for characters */
lit_utf8_size_t buffer_size) /**< size of the buffer */
{
JERRY_ASSERT (collection_p != NULL);
lit_utf8_byte_t *out_chars_buf_iter_p = chars_buffer;
const lit_utf8_size_t chars_number = collection_p->unit_number;
mem_cpointer_t next_chunk_cp = collection_p->first_chunk_cp;
const lit_utf8_byte_t *cur_char_buf_iter_p = NULL;
const lit_utf8_byte_t *cur_char_buf_end_p = NULL;
for (lit_utf8_size_t char_index = 0;
char_index < chars_number;
char_index++)
{
if (cur_char_buf_iter_p == cur_char_buf_end_p)
{
const ecma_collection_chunk_t *chunk_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_chunk_t, next_chunk_cp);
cur_char_buf_iter_p = (lit_utf8_byte_t *) chunk_p->data;
cur_char_buf_end_p = cur_char_buf_iter_p + sizeof (chunk_p->data);
next_chunk_cp = chunk_p->next_chunk_cp;
}
JERRY_ASSERT (cur_char_buf_iter_p + 1 <= cur_char_buf_end_p);
*out_chars_buf_iter_p++ = *cur_char_buf_iter_p++;
}
JERRY_ASSERT (out_chars_buf_iter_p - chars_buffer <= (ssize_t) buffer_size);
} /* ecma_copy_chars_collection_to_buffer */
/**
* Free the collection of ecma-chars.
*/
static void
ecma_free_chars_collection (ecma_collection_header_t *collection_p) /**< collection's header */
{
JERRY_ASSERT (collection_p != NULL);
ecma_collection_chunk_t *chunk_p = ECMA_GET_POINTER (ecma_collection_chunk_t,
collection_p->first_chunk_cp);
while (chunk_p != NULL)
{
ecma_collection_chunk_t *next_chunk_p = ECMA_GET_POINTER (ecma_collection_chunk_t,
chunk_p->next_chunk_cp);
ecma_dealloc_collection_chunk (chunk_p);
chunk_p = next_chunk_p;
}
ecma_dealloc_collection_header (collection_p);
} /* ecma_free_chars_collection */
/**
* Initialize ecma-string descriptor with string described by index in literal table
@ -322,10 +73,9 @@ static void
ecma_init_ecma_string_from_lit_cp (ecma_string_t *string_p, /**< descriptor to initialize */
lit_cpointer_t lit_cp) /**< compressed pointer to literal */
{
lit_literal_t lit = lit_get_literal_by_cp (lit_cp);
rcs_record_type_t type = rcs_record_get_type (lit);
lit_literal_t lit = lit_cpointer_decompress (lit_cp);
if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
if (LIT_RECORD_IS_MAGIC_STR (lit))
{
ecma_init_ecma_string_from_magic_string_id (string_p,
lit_magic_literal_get_magic_str_id (lit));
@ -333,14 +83,14 @@ ecma_init_ecma_string_from_lit_cp (ecma_string_t *string_p, /**< descriptor to i
return;
}
if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
if (LIT_RECORD_IS_MAGIC_STR_EX (lit))
{
ecma_init_ecma_string_from_magic_string_ex_id (string_p,
lit_magic_literal_ex_get_magic_str_id (lit));
lit_magic_literal_get_magic_str_ex_id (lit));
return;
}
JERRY_ASSERT (RCS_RECORD_TYPE_IS_CHARSET (type));
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
string_p->refs = 1;
string_p->container = ECMA_STRING_CONTAINER_LIT_TABLE;
@ -416,8 +166,13 @@ ecma_new_ecma_string_from_utf8 (const lit_utf8_byte_t *string_p, /**< utf-8 stri
string_desc_p->hash = lit_utf8_string_calc_hash (string_p, string_size);
string_desc_p->u.common_field = 0;
ecma_collection_header_t *collection_p = ecma_new_chars_collection (string_p, string_size);
ECMA_SET_NON_NULL_POINTER (string_desc_p->u.collection_cp, collection_p);
const size_t data_size = string_size + sizeof (ecma_string_heap_header_t);
ecma_string_heap_header_t *data_p = (ecma_string_heap_header_t *) mem_heap_alloc_block (data_size);
data_p->size = (uint16_t) string_size;
data_p->length = (uint16_t) lit_utf8_string_length (string_p, string_size);
memcpy (data_p + 1, string_p, string_size);
ECMA_SET_NON_NULL_POINTER (string_desc_p->u.collection_cp, data_p);
return string_desc_p;
} /* ecma_new_ecma_string_from_utf8 */
@ -562,8 +317,8 @@ ecma_concat_ecma_strings (ecma_string_t *string1_p, /**< first ecma-string */
JERRY_ASSERT (string1_p != NULL
&& string2_p != NULL);
lit_utf8_size_t str1_size = ecma_string_get_size (string1_p);
lit_utf8_size_t str2_size = ecma_string_get_size (string2_p);
const lit_utf8_size_t str1_size = ecma_string_get_size (string1_p);
const lit_utf8_size_t str2_size = ecma_string_get_size (string2_p);
if (str1_size == 0)
{
@ -574,30 +329,37 @@ ecma_concat_ecma_strings (ecma_string_t *string1_p, /**< first ecma-string */
return ecma_copy_or_ref_ecma_string (string1_p);
}
int64_t length = (int64_t) str1_size + (int64_t) str2_size;
const lit_utf8_size_t new_size = str1_size + str2_size;
if (length > ECMA_STRING_MAX_CONCATENATION_LENGTH)
{
jerry_fatal (ERR_OUT_OF_MEMORY);
}
ecma_string_t *string_desc_p = ecma_alloc_string ();
string_desc_p->refs = 1;
string_desc_p->container = ECMA_STRING_CONTAINER_HEAP_CHUNKS;
lit_utf8_size_t buffer_size = str1_size + str2_size;
lit_utf8_byte_t *str_p = (lit_utf8_byte_t *) mem_heap_alloc_block (buffer_size, MEM_HEAP_ALLOC_SHORT_TERM);
string_desc_p->u.common_field = 0;
const size_t data_size = new_size + sizeof (ecma_string_heap_header_t);
ecma_string_heap_header_t *data_p = (ecma_string_heap_header_t *) mem_heap_alloc_block (data_size);
ssize_t bytes_copied1, bytes_copied2;
bytes_copied1 = ecma_string_to_utf8_string (string1_p, str_p, (ssize_t) str1_size);
bytes_copied1 = ecma_string_to_utf8_string (string1_p,
(lit_utf8_byte_t *) (data_p + 1),
(ssize_t) str1_size);
JERRY_ASSERT (bytes_copied1 > 0);
bytes_copied2 = ecma_string_to_utf8_string (string2_p, str_p + str1_size, (ssize_t) str2_size);
bytes_copied2 = ecma_string_to_utf8_string (string2_p,
(lit_utf8_byte_t *) (data_p + 1) + str1_size,
(ssize_t) str2_size);
JERRY_ASSERT (bytes_copied2 > 0);
ecma_string_t *str_concat_p = ecma_new_ecma_string_from_utf8 (str_p, buffer_size);
data_p->size = (uint16_t) new_size;
data_p->length = (uint16_t) (ecma_string_get_length (string1_p) + ecma_string_get_length (string2_p));
string_desc_p->hash = lit_utf8_string_hash_combine (string1_p->hash,
(lit_utf8_byte_t *) (data_p + 1) + str1_size,
(lit_utf8_size_t) str2_size);
mem_heap_free_block ((void *) str_p);
ECMA_SET_NON_NULL_POINTER (string_desc_p->u.collection_cp, data_p);
return str_concat_p;
return string_desc_p;
} /* ecma_concat_ecma_strings */
/**
@ -643,12 +405,14 @@ ecma_copy_ecma_string (ecma_string_t *string_desc_p) /**< string descriptor */
new_str_p = ecma_alloc_string ();
*new_str_p = *string_desc_p;
const ecma_collection_header_t *chars_collection_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_header_t,
string_desc_p->u.collection_cp);
JERRY_ASSERT (chars_collection_p != NULL);
ecma_collection_header_t *new_chars_collection_p = ecma_copy_chars_collection (chars_collection_p);
const ecma_string_heap_header_t *data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string_desc_p->u.collection_cp);
JERRY_ASSERT (data_p != NULL);
const size_t data_size = data_p->size + sizeof (ecma_string_heap_header_t);
ecma_string_heap_header_t *new_data_p = (ecma_string_heap_header_t *) mem_heap_alloc_block (data_size);
memcpy (new_data_p, data_p, data_p->size + sizeof (ecma_string_heap_header_t));
ECMA_SET_NON_NULL_POINTER (new_str_p->u.collection_cp, new_chars_collection_p);
ECMA_SET_NON_NULL_POINTER (new_str_p->u.collection_cp, data_p);
break;
}
@ -725,10 +489,10 @@ ecma_deref_ecma_string (ecma_string_t *string_p) /**< ecma-string */
{
case ECMA_STRING_CONTAINER_HEAP_CHUNKS:
{
ecma_collection_header_t *chars_collection_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_header_t,
string_p->u.collection_cp);
ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string_p->u.collection_cp);
ecma_free_chars_collection (chars_collection_p);
mem_heap_free_block (data_p, data_p->size + sizeof (ecma_string_heap_header_t));
break;
}
@ -900,17 +664,16 @@ ecma_string_to_utf8_string (const ecma_string_t *string_desc_p, /**< ecma-string
{
case ECMA_STRING_CONTAINER_HEAP_CHUNKS:
{
const ecma_collection_header_t *chars_collection_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_header_t,
string_desc_p->u.collection_cp);
ecma_copy_chars_collection_to_buffer (chars_collection_p, buffer_p, (lit_utf8_size_t) buffer_size);
const ecma_string_heap_header_t *data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string_desc_p->u.collection_cp);
memcpy (buffer_p, data_p + 1, (size_t) data_p->size);
break;
}
case ECMA_STRING_CONTAINER_LIT_TABLE:
{
lit_literal_t lit = lit_get_literal_by_cp (string_desc_p->u.lit_cp);
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (lit));
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
lit_literal_to_utf8_string (lit, buffer_p, (size_t) required_buffer_size);
break;
}
@ -980,7 +743,7 @@ ecma_compare_ecma_strings_longpath (const ecma_string_t *string1_p, /* ecma-stri
{
case ECMA_STRING_CONTAINER_LIT_TABLE:
{
JERRY_ASSERT (string1_p->u.lit_cp.u.packed_value != string2_p->u.lit_cp.u.packed_value);
JERRY_ASSERT (string1_p->u.lit_cp != string2_p->u.lit_cp);
return false;
}
case ECMA_STRING_CONTAINER_MAGIC_STRING:
@ -1042,37 +805,88 @@ ecma_compare_ecma_strings_longpath (const ecma_string_t *string1_p, /* ecma-stri
}
case ECMA_STRING_CONTAINER_HEAP_CHUNKS:
{
const ecma_collection_header_t *chars_collection1_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_header_t,
string1_p->u.collection_cp);
const ecma_collection_header_t *chars_collection2_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_header_t,
string2_p->u.collection_cp);
const ecma_string_heap_header_t *data1_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string1_p->u.collection_cp);
const ecma_string_heap_header_t *data2_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string2_p->u.collection_cp);
return ecma_compare_chars_collection (chars_collection1_p, chars_collection2_p);
if (data1_p->length != data2_p->length)
{
return false;
}
return !strncmp ((char *) (data1_p + 1), (char *) (data2_p + 1), strings_size);
}
default:
{
JERRY_ASSERT (false);
JERRY_UNREACHABLE ();
break;
}
}
}
bool is_equal = false;
lit_utf8_byte_t *utf8_string1_p, *utf8_string2_p;
bool is_utf8_string1_on_heap = false;
bool is_utf8_string2_on_heap = false;
MEM_DEFINE_LOCAL_ARRAY (string1_buf, strings_size, lit_utf8_byte_t);
MEM_DEFINE_LOCAL_ARRAY (string2_buf, strings_size, lit_utf8_byte_t);
if (string1_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS)
{
const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string1_p->u.collection_cp);
ssize_t req_size;
utf8_string1_p = (lit_utf8_byte_t *) (data_p + 1);
}
else if (string1_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
{
const lit_literal_t lit = lit_get_literal_by_cp (string1_p->u.lit_cp);
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
req_size = (ssize_t) ecma_string_to_utf8_string (string1_p, string1_buf, (ssize_t) strings_size);
JERRY_ASSERT (req_size > 0);
req_size = (ssize_t) ecma_string_to_utf8_string (string2_p, string2_buf, (ssize_t) strings_size);
JERRY_ASSERT (req_size > 0);
utf8_string1_p = (lit_utf8_byte_t *) lit_charset_literal_get_charset (lit);
}
else
{
utf8_string1_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) strings_size);
is_equal = (memcmp (string1_buf, string2_buf, (size_t) strings_size) == 0);
ssize_t bytes_copied = ecma_string_to_utf8_string (string1_p, utf8_string1_p, (ssize_t) strings_size);
JERRY_ASSERT (bytes_copied > 0);
MEM_FINALIZE_LOCAL_ARRAY (string2_buf);
MEM_FINALIZE_LOCAL_ARRAY (string1_buf);
is_utf8_string1_on_heap = true;
}
if (string2_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS)
{
const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string2_p->u.collection_cp);
utf8_string2_p = (lit_utf8_byte_t *) (data_p + 1);
}
else if (string2_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
{
const lit_literal_t lit = lit_get_literal_by_cp (string2_p->u.lit_cp);
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
utf8_string2_p = (lit_utf8_byte_t *) lit_charset_literal_get_charset (lit);
}
else
{
utf8_string2_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) strings_size);
ssize_t bytes_copied = ecma_string_to_utf8_string (string2_p, utf8_string2_p, (ssize_t) strings_size);
JERRY_ASSERT (bytes_copied > 0);
is_utf8_string2_on_heap = true;
}
const bool is_equal = !strncmp ((char *) utf8_string1_p, (char *) utf8_string2_p, (size_t) strings_size);
if (is_utf8_string1_on_heap)
{
mem_heap_free_block ((void *) utf8_string1_p, (size_t) strings_size);
}
if (is_utf8_string2_on_heap)
{
mem_heap_free_block ((void *) utf8_string2_p, (size_t) strings_size);
}
return is_equal;
} /* ecma_compare_ecma_strings_longpath */
@ -1158,46 +972,81 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
lit_utf8_byte_t utf8_string2_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t utf8_string2_size;
ssize_t req_size = ecma_string_to_utf8_string (string1_p, utf8_string1_buffer, sizeof (utf8_string1_buffer));
if (req_size < 0)
if (string1_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS)
{
lit_utf8_byte_t *heap_buffer_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) -req_size,
MEM_HEAP_ALLOC_SHORT_TERM);
const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string1_p->u.collection_cp);
ssize_t bytes_copied = ecma_string_to_utf8_string (string1_p, heap_buffer_p, -req_size);
utf8_string1_size = (lit_utf8_size_t) bytes_copied;
utf8_string1_p = (lit_utf8_byte_t *) (data_p + 1);
utf8_string1_size = (lit_utf8_size_t) data_p->size;
}
else if (string1_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
{
const lit_literal_t lit = lit_get_literal_by_cp (string1_p->u.lit_cp);
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
JERRY_ASSERT (bytes_copied > 0);
utf8_string1_p = heap_buffer_p;
is_utf8_string1_on_heap = true;
utf8_string1_p = (lit_utf8_byte_t *) lit_charset_literal_get_charset (lit);
utf8_string1_size = (lit_utf8_size_t) lit_charset_literal_get_size (lit);
}
else
{
utf8_string1_p = utf8_string1_buffer;
utf8_string1_size = (lit_utf8_size_t) req_size;
const ssize_t req_size = ecma_string_to_utf8_string (string1_p, utf8_string1_buffer, sizeof (utf8_string1_buffer));
if (req_size < 0)
{
lit_utf8_byte_t *heap_buffer_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) -req_size);
ssize_t bytes_copied = ecma_string_to_utf8_string (string1_p, heap_buffer_p, -req_size);
utf8_string1_size = (lit_utf8_size_t) bytes_copied;
JERRY_ASSERT (bytes_copied > 0);
utf8_string1_p = heap_buffer_p;
is_utf8_string1_on_heap = true;
}
else
{
utf8_string1_p = utf8_string1_buffer;
utf8_string1_size = (lit_utf8_size_t) req_size;
}
}
req_size = ecma_string_to_utf8_string (string2_p, utf8_string2_buffer, sizeof (utf8_string2_buffer));
if (req_size < 0)
if (string2_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS)
{
lit_utf8_byte_t *heap_buffer_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) -req_size,
MEM_HEAP_ALLOC_SHORT_TERM);
const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string2_p->u.collection_cp);
ssize_t bytes_copied = ecma_string_to_utf8_string (string2_p, heap_buffer_p, -req_size);
utf8_string2_size = (lit_utf8_size_t) bytes_copied;
utf8_string2_p = (lit_utf8_byte_t *) (data_p + 1);
utf8_string2_size = (lit_utf8_size_t) data_p->size;
}
else if (string2_p->container == ECMA_STRING_CONTAINER_LIT_TABLE)
{
const lit_literal_t lit = lit_get_literal_by_cp (string2_p->u.lit_cp);
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
JERRY_ASSERT (bytes_copied > 0);
utf8_string2_p = heap_buffer_p;
is_utf8_string2_on_heap = true;
utf8_string2_p = (lit_utf8_byte_t *) lit_charset_literal_get_charset (lit);
utf8_string2_size = (lit_utf8_size_t) lit_charset_literal_get_size (lit);
}
else
{
utf8_string2_p = utf8_string2_buffer;
utf8_string2_size = (lit_utf8_size_t) req_size;
const ssize_t req_size = ecma_string_to_utf8_string (string2_p, utf8_string2_buffer, sizeof (utf8_string2_buffer));
if (req_size < 0)
{
lit_utf8_byte_t *heap_buffer_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) -req_size);
ssize_t bytes_copied = ecma_string_to_utf8_string (string2_p, heap_buffer_p, -req_size);
utf8_string2_size = (lit_utf8_size_t) bytes_copied;
JERRY_ASSERT (bytes_copied > 0);
utf8_string2_p = heap_buffer_p;
is_utf8_string2_on_heap = true;
}
else
{
utf8_string2_p = utf8_string2_buffer;
utf8_string2_size = (lit_utf8_size_t) req_size;
}
}
bool is_first_less_than_second = lit_compare_utf8_strings_relational (utf8_string1_p,
@ -1207,12 +1056,12 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
if (is_utf8_string1_on_heap)
{
mem_heap_free_block ((void *) utf8_string1_p);
mem_heap_free_block ((void *) utf8_string1_p, (size_t) utf8_string1_size);
}
if (is_utf8_string2_on_heap)
{
mem_heap_free_block ((void *) utf8_string2_p);
mem_heap_free_block ((void *) utf8_string2_p, (size_t) utf8_string2_size);
}
return is_first_less_than_second;
@ -1288,7 +1137,7 @@ ecma_string_get_length (const ecma_string_t *string_p) /**< ecma-string */
case ECMA_STRING_CONTAINER_LIT_TABLE:
{
lit_literal_t lit = lit_get_literal_by_cp (string_p->u.lit_cp);
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (lit));
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
return lit_charset_literal_get_length (lit);
}
case ECMA_STRING_CONTAINER_MAGIC_STRING:
@ -1314,11 +1163,10 @@ ecma_string_get_length (const ecma_string_t *string_p) /**< ecma-string */
default:
{
JERRY_ASSERT ((ecma_string_container_t) string_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS);
const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string_p->u.collection_cp);
const ecma_collection_header_t *collection_header_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_header_t,
string_p->u.collection_cp);
return ecma_get_chars_collection_length (collection_header_p);
return (ecma_length_t) data_p->length;
}
}
} /* ecma_string_get_length */
@ -1336,7 +1184,7 @@ ecma_string_get_size (const ecma_string_t *string_p) /**< ecma-string */
case ECMA_STRING_CONTAINER_LIT_TABLE:
{
lit_literal_t lit = lit_get_literal_by_cp (string_p->u.lit_cp);
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (lit));
JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit));
return lit_charset_literal_get_size (lit);
}
@ -1359,10 +1207,10 @@ ecma_string_get_size (const ecma_string_t *string_p) /**< ecma-string */
default:
{
JERRY_ASSERT ((ecma_string_container_t) string_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS);
const ecma_collection_header_t *collection_header_p = ECMA_GET_NON_NULL_POINTER (ecma_collection_header_t,
string_p->u.collection_cp);
const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
string_p->u.collection_cp);
return collection_header_p->unit_number;
return (lit_utf8_size_t) data_p->size;
}
}
} /* ecma_string_get_size */

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

@ -1391,7 +1391,7 @@ ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p) /**< byte code pointer */
for (uint32_t i = const_literal_end; i < literal_end; i++)
{
mem_cpointer_t bytecode_cpointer = literal_start_p[i].u.value.base_cp;
mem_cpointer_t bytecode_cpointer = literal_start_p[i];
ecma_compiled_code_t *bytecode_literal_p = ECMA_GET_NON_NULL_POINTER (ecma_compiled_code_t,
bytecode_cpointer);
@ -1411,7 +1411,7 @@ ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p) /**< byte code pointer */
#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN */
}
mem_heap_free_block (bytecode_p);
mem_heap_free_block_size_stored (bytecode_p);
} /* ecma_bytecode_deref */
/**

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

@ -25,6 +25,7 @@
#define JERRY_ECMA_HELPERS_H
#include "ecma-globals.h"
#include "lit-cpointer.h"
#include "lit-strings.h"
#include "mem-allocator.h"

2
jerry-core/ecma/operations/ecma-objects-arguments.c
View File

@ -138,7 +138,7 @@ ecma_op_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function
indx++)
{
// i.
if (literal_p[indx].u.packed_value == MEM_CP_NULL)
if (literal_p[indx] == MEM_CP_NULL)
{
continue;
}

4
jerry-core/ecma/operations/ecma-objects.c
View File

@ -755,9 +755,9 @@ ecma_op_object_get_property_names (ecma_object_t *obj_p, /**< object */
JERRY_ASSERT (insertion_pos < array_index_name_pos);
JERRY_ASSERT (index >= array_index_names_p[insertion_pos]);
uint32_t move_pos = ++array_index_name_pos;
uint32_t move_pos = array_index_name_pos++;
while (move_pos != insertion_pos)
while (move_pos > insertion_pos)
{
array_index_names_p[move_pos] = array_index_names_p[move_pos - 1u];

56
jerry-core/jerry.c
View File

@ -1,4 +1,5 @@
/* Copyright 2015-2016 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -1967,14 +1968,14 @@ jerry_snapshot_set_offsets (uint8_t *buffer_p, /**< buffer */
{
lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
if (literal_start_p[i].u.packed_value != MEM_CP_NULL)
if (literal_start_p[i] != MEM_CP_NULL)
{
while (current_p->literal_id.u.packed_value != literal_start_p[i].u.packed_value)
while (current_p->literal_id != literal_start_p[i])
{
current_p++;
}
literal_start_p[i].u.packed_value = (uint16_t) current_p->literal_offset;
literal_start_p[i] = (uint16_t) current_p->literal_offset;
}
}
@ -1982,13 +1983,13 @@ jerry_snapshot_set_offsets (uint8_t *buffer_p, /**< buffer */
{
compiled_code_map_entry_t *current_p = snapshot_map_entries_p;
while (current_p->compiled_code_cp != literal_start_p[i].u.value.base_cp)
while (current_p->compiled_code_cp != literal_start_p[i])
{
current_p = ECMA_GET_NON_NULL_POINTER (compiled_code_map_entry_t,
current_p->next_cp);
}
literal_start_p[i].u.packed_value = (uint16_t) current_p->offset;
literal_start_p[i] = (uint16_t) current_p->offset;
}
}
@ -2095,26 +2096,17 @@ jerry_parse_and_save_snapshot (const jerry_api_char_t *source_p, /**< script sou
}
else
{
if (header.lit_table_size > 0xffff)
{
/* Aligning literals could increase this range, but
* it is not a requirement for low-memory environments. */
snapshot_buffer_write_offset = 0;
}
else
{
jerry_snapshot_set_offsets (buffer_p + compiled_code_start,
(uint32_t) compiled_code_size,
lit_map_p);
jerry_snapshot_set_offsets (buffer_p + compiled_code_start,
(uint32_t) compiled_code_size,
lit_map_p);
jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
&header_offset,
&header,
sizeof (header));
}
jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
&header_offset,
&header,
sizeof (header));
mem_heap_free_block (lit_map_p);
mem_heap_free_block_size_stored (lit_map_p);
}
ecma_bytecode_deref (bytecode_data_p);
@ -2212,8 +2204,7 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
if (copy_bytecode)
{
bytecode_p = (ecma_compiled_code_t *) mem_heap_alloc_block (code_size,
MEM_HEAP_ALLOC_LONG_TERM);
bytecode_p = (ecma_compiled_code_t *) mem_heap_alloc_block_store_size (code_size);
memcpy (bytecode_p, snapshot_data_p + offset + sizeof (uint32_t), code_size);
}
@ -2223,8 +2214,7 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
uint8_t *real_bytecode_p = ((uint8_t *) bytecode_p) + code_size;
bytecode_p = (ecma_compiled_code_t *) mem_heap_alloc_block (code_size + 1 + sizeof (uint8_t *),
MEM_HEAP_ALLOC_LONG_TERM);
bytecode_p = (ecma_compiled_code_t *) mem_heap_alloc_block_store_size (code_size + 1 + sizeof (uint8_t *));
memcpy (bytecode_p, snapshot_data_p + offset + sizeof (uint32_t), code_size);
@ -2242,9 +2232,9 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
{
lit_mem_to_snapshot_id_map_entry_t *current_p = lit_map_p;
if (literal_start_p[i].u.packed_value != 0)
if (literal_start_p[i] != 0)
{
while (current_p->literal_offset != literal_start_p[i].u.packed_value)
while (current_p->literal_offset != literal_start_p[i])
{
current_p++;
}
@ -2255,12 +2245,12 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
for (uint32_t i = const_literal_end; i < literal_end; i++)
{
size_t literal_offset = ((size_t) literal_start_p[i].u.packed_value) << MEM_ALIGNMENT_LOG;
size_t literal_offset = ((size_t) literal_start_p[i]) << MEM_ALIGNMENT_LOG;
if (literal_offset == offset)
{
/* Self reference */
ECMA_SET_NON_NULL_POINTER (literal_start_p[i].u.value.base_cp,
ECMA_SET_NON_NULL_POINTER (literal_start_p[i],
bytecode_p);
}
else
@ -2271,7 +2261,7 @@ snapshot_load_compiled_code (const uint8_t *snapshot_data_p, /**< snapshot data
lit_map_p,
copy_bytecode);
ECMA_SET_NON_NULL_POINTER (literal_start_p[i].u.value.base_cp,
ECMA_SET_NON_NULL_POINTER (literal_start_p[i],
literal_bytecode_p);
}
}
@ -2357,7 +2347,7 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
if (lit_map_p != NULL)
{
mem_heap_free_block (lit_map_p);
mem_heap_free_block_size_stored (lit_map_p);
}
if (bytecode_p == NULL)

61
jerry-core/lit/lit-cpointer.c Normal file
View File

@ -0,0 +1,61 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "lit-cpointer.h"
#include "jrt-bit-fields.h"
/**
* Compress pointer to extended compressed pointer.
*
* @return dynamic storage-specific extended compressed pointer
*/
lit_cpointer_t __attr_pure___ __attr_always_inline___
lit_cpointer_compress (lit_record_t *pointer) /**< pointer to compress */
{
if (pointer == NULL)
{
return MEM_CP_NULL;
}
return (lit_cpointer_t) mem_compress_pointer (pointer);
} /* lit_cpointer_compress */
/**
* Decompress extended compressed pointer.
*
* @return decompressed pointer
*/
lit_record_t * __attr_pure___ __attr_always_inline___
lit_cpointer_decompress (lit_cpointer_t compressed_pointer) /**< recordset-specific compressed pointer */
{
if (compressed_pointer == MEM_CP_NULL)
{
return NULL;
}
return (lit_record_t *) mem_decompress_pointer (compressed_pointer);
} /* lit_cpointer_decompress */
/**
* Create NULL compressed pointer.
*
* @return NULL compressed pointer
*/
lit_cpointer_t __attr_pure___ __attr_always_inline___
lit_cpointer_null_cp (void)
{
return MEM_CP_NULL;
} /* lit_cpointer_null_cp */

38
jerry-core/lit/lit-cpointer.h Normal file
View File

@ -0,0 +1,38 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef LIT_CPOINTER_H
#define LIT_CPOINTER_H
#include "lit-literal-storage.h"
#include "mem-allocator.h"
#define LIT_CPOINTER_WIDTH (MEM_CP_WIDTH + MEM_ALIGNMENT_LOG - MEM_ALIGNMENT_LOG)
/**
* Dynamic storage-specific extended compressed pointer
*
* Note:
* the pointer can represent addresses aligned by lit_DYN_STORAGE_LENGTH_UNIT,
* while mem_cpointer_t can only represent addresses aligned by MEM_ALIGNMENT.
*/
typedef uint16_t lit_cpointer_t;
extern lit_cpointer_t lit_cpointer_compress (lit_record_t *);
extern lit_record_t *lit_cpointer_decompress (lit_cpointer_t);
extern lit_cpointer_t lit_cpointer_null_cp ();
#endif /* !LIT_CPOINTER_H */

16
jerry-core/lit/lit-globals.h
View File

@ -17,7 +17,6 @@
#define LIT_GLOBALS_H
#include "jrt.h"
#include "rcs-cpointer.h"
/**
* ECMAScript standard defines terms "code unit" and "character" as 16-bit unsigned value
@ -129,21 +128,6 @@ typedef uint32_t lit_code_point_t;
*/
typedef uint8_t lit_string_hash_t;
/**
* Literal type
*/
typedef rcs_record_t *lit_literal_t;
/**
* Compressed pointer type
*/
typedef rcs_cpointer_t lit_cpointer_t;
/**
* Invalid literal
*/
#define NOT_A_LITERAL (rcs_cpointer_null_cp ())
/**
* ECMA string hash value length, in bits
*/

204
jerry-core/lit/lit-literal-storage.c
View File

@ -1,5 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -15,85 +15,144 @@
*/
#include "lit-literal-storage.h"
#include "lit-cpointer.h"
#include "ecma-helpers.h"
#include "rcs-allocator.h"
#include "rcs-iterator.h"
#include "rcs-records.h"
rcs_record_set_t rcs_lit_storage;
lit_record_t *lit_storage = NULL;
/**
* Create charset record in the literal storage
*
* @return pointer to the created record
*/
rcs_record_t *
lit_storage_create_charset_literal (rcs_record_set_t *rec_set_p, /**< recordset */
const lit_utf8_byte_t *str_p, /**< string to be placed into the record */
const lit_utf8_size_t buf_size) /**< size of the string (in bytes) */
lit_record_t *
lit_create_charset_literal (const lit_utf8_byte_t *str_p, /**< string to be placed into the record */
const lit_utf8_size_t buf_size) /**< size in bytes of the buffer which holds the string */
{
const size_t record_size = RCS_CHARSET_HEADER_SIZE + buf_size;
const size_t aligned_record_size = JERRY_ALIGNUP (record_size, RCS_DYN_STORAGE_LENGTH_UNIT);
const size_t alignment = aligned_record_size - record_size;
lit_charset_record_t *rec_p = (lit_charset_record_t *) mem_heap_alloc_block (buf_size + LIT_CHARSET_HEADER_SIZE);
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_CHARSET, aligned_record_size);
rec_p->type = LIT_RECORD_TYPE_CHARSET;
rec_p->next = (uint16_t) lit_cpointer_compress (lit_storage);
lit_storage = (lit_record_t *) rec_p;
rcs_record_set_alignment_bytes_count (rec_p, (uint8_t) alignment);
rcs_record_set_charset (rec_set_p, rec_p, str_p, buf_size);
rcs_record_set_hash (rec_p, lit_utf8_string_calc_hash (str_p, rcs_record_get_length (rec_p)));
rec_p->hash = (uint8_t) lit_utf8_string_calc_hash (str_p, buf_size);
rec_p->size = (uint16_t) buf_size;
rec_p->length = (uint16_t) lit_utf8_string_length (str_p, buf_size);
memcpy (rec_p + 1, str_p, buf_size);
return rec_p;
} /* lit_storage_create_charset_literal */
return (lit_record_t *) rec_p;
} /* lit_create_charset_literal */
/**
* Create magic string record in the literal storage.
*
* @return pointer to the created record
*/
rcs_record_t *
lit_storage_create_magic_literal (rcs_record_set_t *rec_set_p, /**< recordset */
lit_magic_string_id_t id) /**< id of magic string */
lit_record_t *
lit_create_magic_literal (const lit_magic_string_id_t id) /**< id of magic string */
{
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_MAGIC_STR, RCS_MAGIC_STR_HEADER_SIZE);
rcs_record_set_magic_str_id (rec_p, id);
lit_magic_record_t *rec_p = (lit_magic_record_t *) mem_heap_alloc_block (sizeof (lit_magic_record_t));
rec_p->type = LIT_RECORD_TYPE_MAGIC_STR;
rec_p->next = (uint16_t) lit_cpointer_compress (lit_storage);
lit_storage = (lit_record_t *) rec_p;
return rec_p;
} /* lit_storage_create_magic_literal */
rec_p->magic_id = (uint32_t) id;
return (lit_record_t *) rec_p;
} /* lit_create_magic_literal */
/**
* Create external magic string record in the literal storage.
*
* @return pointer to the created record
*/
rcs_record_t *
lit_storage_create_magic_literal_ex (rcs_record_set_t *rec_set_p, /**< recordset */
lit_magic_string_ex_id_t id) /**< id of magic string */
lit_record_t *
lit_create_magic_literal_ex (const lit_magic_string_ex_id_t id) /**< id of magic string */
{
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_MAGIC_STR_EX, RCS_MAGIC_STR_HEADER_SIZE);
rcs_record_set_magic_str_ex_id (rec_p, id);
lit_magic_record_t *rec_p = (lit_magic_record_t *) mem_heap_alloc_block (sizeof (lit_magic_record_t));
rec_p->type = LIT_RECORD_TYPE_MAGIC_STR_EX;
rec_p->next = (uint16_t) lit_cpointer_compress (lit_storage);
lit_storage = (lit_record_t *) rec_p;
return rec_p;
} /* lit_storage_create_magic_literal_ex */
rec_p->magic_id = (uint32_t) id;
return (lit_record_t *) rec_p;
} /* lit_create_magic_literal_ex */
/**
* Create number record in the literal storage.
*
* @return pointer to the created record
*/
rcs_record_t *
lit_storage_create_number_literal (rcs_record_set_t *rec_set_p, /**< recordset */
ecma_number_t num) /**< numeric value */
lit_record_t *
lit_create_number_literal (const ecma_number_t num) /**< numeric value */
{
const size_t record_size = RCS_NUMBER_HEADER_SIZE + sizeof (ecma_number_t);
rcs_record_t *rec_p = rcs_alloc_record (rec_set_p, RCS_RECORD_TYPE_NUMBER, record_size);
lit_number_record_t *rec_p = (lit_number_record_t *) mem_heap_alloc_block (sizeof (lit_number_record_t));
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_NUMBER_HEADER_SIZE);
rcs_iterator_write (&it_ctx, &num, sizeof (ecma_number_t));
rec_p->type = (uint8_t) LIT_RECORD_TYPE_NUMBER;
rec_p->next = (uint16_t) lit_cpointer_compress (lit_storage);
lit_storage = (lit_record_t *) rec_p;
return rec_p;
} /* lit_storage_create_number_literal */
rec_p->number = num;
return (lit_record_t *) rec_p;
} /* lit_create_number_literal */
/**
* Get size of stored literal
*
* @return size of literal
*/
size_t __attr_pure___
lit_get_literal_size (const lit_record_t *lit_p) /**< literal record */
{
const lit_record_type_t type = (const lit_record_type_t) lit_p->type;
size_t size = 0;
switch (type)
{
case LIT_RECORD_TYPE_NUMBER:
{
size = sizeof (lit_number_record_t);
break;
}
case LIT_RECORD_TYPE_CHARSET:
{
const lit_charset_record_t *const rec_p = (const lit_charset_record_t *) lit_p;
size = rec_p->size + LIT_CHARSET_HEADER_SIZE;
break;
}
case LIT_RECORD_TYPE_MAGIC_STR:
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
size = sizeof (lit_magic_record_t);
break;
}
default:
{
JERRY_UNREACHABLE ();
break;
}
}
JERRY_ASSERT (size > 0);
return size;
} /* lit_get_literal_size */
/**
* Free stored literal
*
* @return pointer to the next literal in the list
*/
lit_record_t *
lit_free_literal (lit_record_t *lit_p) /**< literal record */
{
lit_record_t *const ret_p = lit_cpointer_decompress (lit_p->next);
mem_heap_free_block (lit_p, lit_get_literal_size (lit_p));
return ret_p;
} /* lit_free_literal */
/**
* Count literal records in the storage
@ -101,85 +160,80 @@ lit_storage_create_number_literal (rcs_record_set_t *rec_set_p, /**< recordset *
* @return number of literals
*/
uint32_t
lit_storage_count_literals (rcs_record_set_t *rec_set_p) /**< recordset */
lit_count_literals ()
{
uint32_t num = 0;
rcs_record_t *rec_p;
lit_record_t *rec_p;
for (rec_p = rcs_record_get_first (rec_set_p);
for (rec_p = lit_storage;
rec_p != NULL;
rec_p = rcs_record_get_next (rec_set_p, rec_p))
rec_p = lit_cpointer_decompress (rec_p->next))
{
if (rcs_record_get_type (rec_p) >= RCS_RECORD_TYPE_FIRST)
if (rec_p->type > LIT_RECORD_TYPE_FREE)
{
num++;
}
}
return num;
} /* lit_storage_count_literals */
} /* lit_count_literals */
/**
* Dump the contents of the literal storage.
*/
void
lit_storage_dump_literals (rcs_record_set_t *rec_set_p) /**< recordset */
lit_dump_literals ()
{
rcs_record_t *rec_p;
lit_record_t *rec_p;
size_t i;
printf ("LITERALS:\n");
for (rec_p = rcs_record_get_first (rec_set_p);
for (rec_p = lit_storage;
rec_p != NULL;
rec_p = rcs_record_get_next (rec_set_p, rec_p))
rec_p = lit_cpointer_decompress (rec_p->next))
{
printf ("%p ", rec_p);
printf ("[%3zu] ", rcs_record_get_size (rec_p));
printf ("[%3zu] ", lit_get_literal_size (rec_p));
switch (rcs_record_get_type (rec_p))
switch (rec_p->type)
{
case RCS_RECORD_TYPE_CHARSET:
case LIT_RECORD_TYPE_CHARSET:
{
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
size_t str_len = rcs_record_get_length (rec_p);
size_t i;
for (i = 0; i < str_len; ++i)
const lit_charset_record_t *const record_p = (const lit_charset_record_t *) rec_p;
char *str = (char *) (record_p + 1);
for (i = 0; i < record_p->size; ++i, ++str)
{
FIXME ("Support proper printing of characters which occupy more than one byte.")
lit_utf8_byte_t chr;
rcs_iterator_read (&it_ctx, &chr, sizeof (lit_utf8_byte_t));
rcs_iterator_skip (&it_ctx, sizeof (lit_utf8_byte_t));
printf ("%c", chr);
printf ("%c", *str);
}
printf (" : STRING");
break;
}
case RCS_RECORD_TYPE_MAGIC_STR:
case LIT_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t id = rcs_record_get_magic_str_id (rec_p);
lit_magic_string_id_t id = (lit_magic_string_id_t) ((lit_magic_record_t *) rec_p)->magic_id;
printf ("%s : MAGIC STRING", lit_get_magic_string_utf8 (id));
printf (" [id=%d] ", id);
break;
}
case RCS_RECORD_TYPE_MAGIC_STR_EX:
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t id = rcs_record_get_magic_str_ex_id (rec_p);
lit_magic_string_ex_id_t id = ((lit_magic_record_t *) rec_p)->magic_id;
printf ("%s : EXT MAGIC STRING", lit_get_magic_string_ex_utf8 (id));
printf (" [id=%d] ", id);
break;
}
case RCS_RECORD_TYPE_NUMBER:
case LIT_RECORD_TYPE_NUMBER:
{
ecma_number_t value = rcs_record_get_number (rec_set_p, rec_p);
const lit_number_record_t *const record_p = (const lit_number_record_t *) rec_p;
ecma_number_t value;
memcpy (&value, &record_p->number, sizeof (ecma_number_t));
if (ecma_number_is_nan (value))
{
@ -200,10 +254,10 @@ lit_storage_dump_literals (rcs_record_set_t *rec_set_p) /**< recordset */
}
default:
{
printf (" : EMPTY RECORD");
JERRY_UNREACHABLE ();
}
}
printf ("\n");
}
} /* lit_storage_dump_literals */
} /* lit_dump_literals */

87
jerry-core/lit/lit-literal-storage.h
View File

@ -1,5 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,16 +17,87 @@
#ifndef LIT_LITERAL_STORAGE_H
#define LIT_LITERAL_STORAGE_H
#include "lit-magic-strings.h"
#include "lit-globals.h"
#include "ecma-globals.h"
extern rcs_record_set_t rcs_lit_storage;
/**
* Represents the type of the record.
*/
typedef enum
{
LIT_RECORD_TYPE_FREE = 0, /**< Free record that marks an empty space. It doesn't hold any values. */
LIT_RECORD_TYPE_CHARSET = 1, /**< Charset record that holds characters. */
LIT_RECORD_TYPE_MAGIC_STR = 2, /**< Magic string record that holds a magic string id. */
LIT_RECORD_TYPE_MAGIC_STR_EX = 3, /**< External magic string record that holds an extrernal magic string id. */
LIT_RECORD_TYPE_NUMBER = 4 /**< Number record that holds a numeric value. */
} lit_record_type_t;
extern rcs_record_t *lit_storage_create_charset_literal (rcs_record_set_t *, const lit_utf8_byte_t *, lit_utf8_size_t);
extern rcs_record_t *lit_storage_create_magic_literal (rcs_record_set_t *, lit_magic_string_id_t);
extern rcs_record_t *lit_storage_create_magic_literal_ex (rcs_record_set_t *, lit_magic_string_ex_id_t);
extern rcs_record_t *lit_storage_create_number_literal (rcs_record_set_t *, ecma_number_t);
/**
* Record header
*/
typedef struct
{
uint16_t next; /* Compressed pointer to next record */
uint8_t type; /* Type of record */
} lit_record_t;
extern uint32_t lit_storage_count_literals (rcs_record_set_t *);
extern void lit_storage_dump_literals (rcs_record_set_t *);
/**
* Head pointer to literal storage
*/
extern lit_record_t *lit_storage;
typedef lit_record_t *lit_literal_t;
/**
* Charset record header
*
* String is stored after the header.
*/
typedef struct
{
uint16_t next; /* Compressed pointer to next record */
uint8_t type; /* Type of record */
uint8_t hash; /* Hash of the string */
uint16_t size; /* Size of the string in bytes */
uint16_t length; /* Number of character in the string */
} lit_charset_record_t;
/**
* Number record header
*/
typedef struct
{
uint16_t next; /* Compressed pointer to next record */
uint8_t type; /* Type of record */
ecma_number_t number; /* Number stored in the record */
} lit_number_record_t;
/**
* Magic record header
*/
typedef struct
{
uint16_t next; /* Compressed pointer to next record */
uint8_t type; /* Type of record */
uint32_t magic_id; /* Magic ID stored in the record */
} lit_magic_record_t;
#define LIT_CHARSET_HEADER_SIZE (sizeof(lit_charset_record_t))
extern lit_record_t *lit_create_charset_literal (const lit_utf8_byte_t *, const lit_utf8_size_t);
extern lit_record_t *lit_create_magic_literal (const lit_magic_string_id_t);
extern lit_record_t *lit_create_magic_literal_ex (const lit_magic_string_ex_id_t);
extern lit_record_t *lit_create_number_literal (const ecma_number_t);
extern lit_record_t *lit_free_literal (lit_record_t *);
extern size_t lit_get_literal_size (const lit_record_t *);
extern uint32_t lit_count_literals ();
extern void lit_dump_literals ();
#define LIT_RECORD_IS_CHARSET(lit) (((lit_record_t *) lit)->type == LIT_RECORD_TYPE_CHARSET)
#define LIT_RECORD_IS_MAGIC_STR(lit) (((lit_record_t *) lit)->type == LIT_RECORD_TYPE_MAGIC_STR)
#define LIT_RECORD_IS_MAGIC_STR_EX(lit) (((lit_record_t *) lit)->type == LIT_RECORD_TYPE_MAGIC_STR_EX)
#define LIT_RECORD_IS_NUMBER(lit) (((lit_record_t *) lit)->type == LIT_RECORD_TYPE_NUMBER)
#endif /* !LIT_LITERAL_STORAGE_H */

384
jerry-core/lit/lit-literal.c
View File

@ -1,4 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -16,21 +17,17 @@
#include "lit-literal.h"
#include "ecma-helpers.h"
#include "rcs-allocator.h"
#include "rcs-records.h"
#include "rcs-iterator.h"
#include "lit-cpointer.h"
#include "lit-magic-strings.h"
#include "lit-literal-storage.h"
/**
* Initialize literal storage
*/
void
lit_init (void)
{
JERRY_ASSERT (rcs_get_node_data_space_size () % RCS_DYN_STORAGE_LENGTH_UNIT == 0);
rcs_chunked_list_init (&rcs_lit_storage);
lit_magic_strings_ex_init ();
} /* lit_init */
@ -40,19 +37,12 @@ lit_init (void)
void
lit_finalize (void)
{
rcs_chunked_list_cleanup (&rcs_lit_storage);
rcs_chunked_list_free (&rcs_lit_storage);
while (lit_storage)
{
lit_storage = lit_free_literal (lit_storage);
}
} /* lit_finalize */
/**
* Dump records from the literal storage
*/
void
lit_dump_literals (void)
{
lit_storage_dump_literals (&rcs_lit_storage);
} /* lit_dump_literals */
/**
* Create new literal in literal storage from characters buffer.
* Don't check if the same literal already exists.
@ -78,7 +68,7 @@ lit_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string t
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_utf8 (m_str_id), str_size))
{
return lit_storage_create_magic_literal (&rcs_lit_storage, m_str_id);
return lit_create_magic_literal (m_str_id);
}
}
@ -94,11 +84,11 @@ lit_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string t
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_ex_utf8 (m_str_ex_id), str_size))
{
return lit_storage_create_magic_literal_ex (&rcs_lit_storage, m_str_ex_id);
return lit_create_magic_literal_ex (m_str_ex_id);
}
}
return lit_storage_create_charset_literal (&rcs_lit_storage, str_p, str_size);
return lit_create_charset_literal (str_p, str_size);
} /* lit_create_literal_from_utf8_string */
/**
@ -117,57 +107,73 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
for (lit = lit_storage;
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
lit = lit_cpointer_decompress (lit->next))
{
rcs_record_type_t type = rcs_record_get_type (lit);
const lit_record_type_t type = (lit_record_type_t) lit->type;
if (RCS_RECORD_TYPE_IS_CHARSET (type))
switch (type)
{
if (rcs_record_get_hash (lit) != str_hash)
case LIT_RECORD_TYPE_CHARSET:
{
continue;
}
const lit_charset_record_t *const rec_p = (const lit_charset_record_t *) lit;
if (rcs_record_get_length (lit) != str_size)
{
continue;
}
if (rec_p->hash != str_hash)
{
continue;
}
if (rcs_record_is_equal_charset (&rcs_lit_storage, lit, str_p, str_size))
{
return lit;
}
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
{
lit_magic_string_id_t magic_id = rcs_record_get_magic_str_id (lit);
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_utf8 (magic_id);
if (rec_p->size != str_size)
{
continue;
}
if (lit_get_magic_string_size (magic_id) != str_size)
{
continue;
}
if (!strncmp (rec_p + 1, (const char *) str_p, str_size))
{
return lit;
}
if (!strncmp ((const char *) magic_str_p, (const char *) str_p, str_size))
{
return lit;
break;
}
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
{
lit_magic_string_ex_id_t magic_id = rcs_record_get_magic_str_ex_id (lit);
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_ex_utf8 (magic_id);
if (lit_get_magic_string_ex_size (magic_id) != str_size)
case LIT_RECORD_TYPE_MAGIC_STR:
{
continue;
lit_magic_string_id_t magic_id = (lit_magic_string_id_t) ((lit_magic_record_t *) lit)->magic_id;
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_utf8 (magic_id);
if (lit_get_magic_string_size (magic_id) != str_size)
{
continue;
}
if (!strncmp ((const char *) magic_str_p, (const char *) str_p, str_size))
{
return lit;
}
break;
}
if (!strncmp ((const char *) magic_str_p, (const char *) str_p, str_size))
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
return lit;
lit_magic_string_ex_id_t magic_id = ((lit_magic_record_t *) lit)->magic_id;
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_ex_utf8 (magic_id);
if (lit_get_magic_string_ex_size (magic_id) != str_size)
{
continue;
}
if (!strncmp ((const char *) magic_str_p, (const char *) str_p, str_size))
{
return lit;
}
break;
}
default:
{
JERRY_ASSERT (type == LIT_RECORD_TYPE_NUMBER);
break;
}
}
}
@ -183,7 +189,7 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
*/
lit_literal_t
lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string, could be non-zero-terminated */
lit_utf8_size_t str_size) /**< length of the string */
const lit_utf8_size_t str_size) /**< length of the string */
{
lit_literal_t lit = lit_find_literal_by_utf8_string (str_p, str_size);
@ -201,10 +207,10 @@ lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**<
*
* @return pointer to a newly created record
*/
lit_literal_t
lit_create_literal_from_num (ecma_number_t num) /**< number to initialize a new number literal */
lit_literal_t __attr_always_inline___
lit_create_literal_from_num (const ecma_number_t num) /**< number to initialize a new number literal */
{
return lit_storage_create_number_literal (&rcs_lit_storage, num);
return lit_create_number_literal (num);
} /* lit_create_literal_from_num */
/**
@ -231,21 +237,21 @@ lit_find_or_create_literal_from_num (ecma_number_t num) /**< number which a lite
* @return pointer to existing or null
*/
lit_literal_t
lit_find_literal_by_num (ecma_number_t num) /**< a number to search for */
lit_find_literal_by_num (const ecma_number_t num) /**< a number to search for */
{
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
for (lit = lit_storage;
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
lit = lit_cpointer_decompress (lit->next))
{
rcs_record_type_t type = rcs_record_get_type (lit);
const lit_record_type_t type = (lit_record_type_t) lit->type;
if (!RCS_RECORD_TYPE_IS_NUMBER (type))
if (type != LIT_RECORD_TYPE_NUMBER)
{
continue;
}
ecma_number_t lit_num = rcs_record_get_number (&rcs_lit_storage, lit);
const ecma_number_t lit_num = lit_number_literal_get_number (lit);
if (lit_num == num)
{
@ -266,37 +272,37 @@ static bool
lit_literal_equal_charset_rec (lit_literal_t lit, /**< literal to compare */
lit_literal_t record) /**< charset record to compare */
{
switch (rcs_record_get_type (lit))
switch (lit->type)
{
case RCS_RECORD_TYPE_CHARSET:
case LIT_RECORD_TYPE_CHARSET:
{
return rcs_record_is_equal (&rcs_lit_storage, lit, record);
return lit_literal_equal_charset (lit,
lit_charset_literal_get_charset (record),
lit_charset_literal_get_size (record));
}
case RCS_RECORD_TYPE_MAGIC_STR:
case LIT_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_string_id = rcs_record_get_magic_str_id (lit);
return rcs_record_is_equal_charset (&rcs_lit_storage,
record,
lit_get_magic_string_utf8 (magic_string_id),
lit_get_magic_string_size (magic_string_id));
lit_magic_string_id_t magic_string_id = lit_magic_literal_get_magic_str_id (lit);
return lit_literal_equal_charset (record,
lit_get_magic_string_utf8 (magic_string_id),
lit_get_magic_string_size (magic_string_id));
}
case RCS_RECORD_TYPE_MAGIC_STR_EX:
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_string_id = rcs_record_get_magic_str_ex_id (lit);
lit_magic_string_ex_id_t magic_string_id = lit_magic_literal_get_magic_str_ex_id (lit);
return rcs_record_is_equal_charset (&rcs_lit_storage,
record,
lit_get_magic_string_ex_utf8 (magic_string_id),
lit_get_magic_string_ex_size (magic_string_id));
return lit_literal_equal_charset (record,
lit_get_magic_string_ex_utf8 (magic_string_id),
lit_get_magic_string_ex_size (magic_string_id));
}
case RCS_RECORD_TYPE_NUMBER:
case LIT_RECORD_TYPE_NUMBER:
{
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit);
ecma_number_t num = lit_number_literal_get_number (lit);
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t copied = ecma_number_to_utf8_string (num, buff, sizeof (buff));
return rcs_record_is_equal_charset (&rcs_lit_storage, record, buff, copied);
return lit_literal_equal_charset (record, buff, copied);
}
default:
{
@ -317,25 +323,29 @@ lit_literal_equal_utf8 (lit_literal_t lit, /**< literal to compare */
const lit_utf8_byte_t *str_p, /**< utf-8 string to compare */
lit_utf8_size_t str_size) /**< string size in bytes */
{
switch (rcs_record_get_type (lit))
switch (lit->type)
{
case RCS_RECORD_TYPE_CHARSET:
case LIT_RECORD_TYPE_CHARSET:
{
return rcs_record_is_equal_charset (&rcs_lit_storage, lit, str_p, str_size);
if (lit_charset_literal_get_size (lit) != str_size)
{
return 0;
}
return !strncmp ((const char *) lit_charset_literal_get_charset (lit), (const char *) str_p, str_size);
}
case RCS_RECORD_TYPE_MAGIC_STR:
case LIT_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_id = rcs_record_get_magic_str_id (lit);
lit_magic_string_id_t magic_id = lit_magic_literal_get_magic_str_id (lit);
return lit_compare_utf8_string_and_magic_string (str_p, str_size, magic_id);
}
case RCS_RECORD_TYPE_MAGIC_STR_EX:
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_id = rcs_record_get_magic_str_ex_id (lit);
lit_magic_string_ex_id_t magic_id = lit_magic_literal_get_magic_str_ex_id (lit);
return lit_compare_utf8_string_and_magic_string_ex (str_p, str_size, magic_id);
}
case RCS_RECORD_TYPE_NUMBER:
case LIT_RECORD_TYPE_NUMBER:
{
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit);
ecma_number_t num = lit_number_literal_get_number (lit);
lit_utf8_byte_t num_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t num_size = ecma_number_to_utf8_string (num, num_buf, sizeof (num_buf));
@ -356,7 +366,7 @@ lit_literal_equal_utf8 (lit_literal_t lit, /**< literal to compare */
* false otherwise
*/
bool
lit_literal_equal_num (lit_literal_t lit, /**< literal to check */
lit_literal_equal_num (lit_literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
@ -365,6 +375,29 @@ lit_literal_equal_num (lit_literal_t lit, /**< literal to check */
return lit_literal_equal_utf8 (lit, buff, copied);
} /* lit_literal_equal_num */
/**
* Check if literal contains the string equal to the buffer
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_charset (lit_literal_t lit, /**< literal to checks */
const lit_utf8_byte_t *buff, /**< string buffer */
lit_utf8_size_t size) /**< buffer size */
{
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_CHARSET);
if (size != lit_charset_literal_get_size (lit))
{
return false;
}
return !strncmp ((const char *) buff, (const char *) lit_charset_literal_get_charset (lit), size);
} /* lit_literal_equal_charset */
/**
* Check if two literals are equal
*
@ -375,38 +408,42 @@ bool
lit_literal_equal (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
switch (rcs_record_get_type (lit2))
switch (lit2->type)
{
case RCS_RECORD_TYPE_CHARSET:
case LIT_RECORD_TYPE_CHARSET:
{
return lit_literal_equal_charset_rec (lit1, lit2);
}
case RCS_RECORD_TYPE_MAGIC_STR:
case LIT_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_str_id = rcs_record_get_magic_str_id (lit2);
lit_magic_string_id_t magic_str_id = lit_magic_literal_get_magic_str_id (lit2);
return lit_literal_equal_utf8 (lit1,
lit_get_magic_string_utf8 (magic_str_id),
lit_get_magic_string_size (magic_str_id));
}
case RCS_RECORD_TYPE_MAGIC_STR_EX:
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_str_ex_id = rcs_record_get_magic_str_ex_id (lit2);
lit_magic_string_ex_id_t magic_str_ex_id = lit_magic_literal_get_magic_str_ex_id (lit2);
return lit_literal_equal_utf8 (lit1,
lit_get_magic_string_ex_utf8 (magic_str_ex_id),
lit_get_magic_string_ex_size (magic_str_ex_id));
}
case RCS_RECORD_TYPE_NUMBER:
case LIT_RECORD_TYPE_NUMBER:
{
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit2);
ecma_number_t num = lit_number_literal_get_number (lit2);
return lit_literal_equal_num (lit1, num);
}
default:
{
JERRY_UNREACHABLE ();
break;
}
}
JERRY_UNREACHABLE ();
return 0;
} /* lit_literal_equal */
/**
@ -421,9 +458,9 @@ lit_literal_equal_type_utf8 (lit_literal_t lit, /**< literal to compare */
const lit_utf8_byte_t *str_p, /**< utf-8 string */
lit_utf8_size_t str_size) /**< string size */
{
rcs_record_type_t type = rcs_record_get_type (lit);
const lit_record_type_t type = (const lit_record_type_t) lit->type;
if (RCS_RECORD_TYPE_IS_NUMBER (type) || RCS_RECORD_TYPE_IS_FREE (type))
if (type == LIT_RECORD_TYPE_NUMBER || type == LIT_RECORD_TYPE_FREE)
{
return false;
}
@ -456,7 +493,7 @@ bool
lit_literal_equal_type_num (lit_literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
if (!RCS_RECORD_IS_NUMBER (lit))
if (lit->type != LIT_RECORD_TYPE_NUMBER)
{
return false;
}
@ -475,7 +512,7 @@ bool
lit_literal_equal_type (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
if (rcs_record_get_type (lit1) != rcs_record_get_type (lit2))
if (lit1->type != lit2->type)
{
return false;
}
@ -496,29 +533,32 @@ lit_literal_to_utf8_string (lit_literal_t lit, /**< literal to be processed */
size_t size) /**< size of the buffer */
{
JERRY_ASSERT (buff_p != NULL && size > 0);
rcs_record_type_t type = rcs_record_get_type (lit);
if (RCS_RECORD_TYPE_IS_CHARSET (type))
switch (lit->type)
{
rcs_record_get_charset (&rcs_lit_storage, lit, buff_p, size);
return buff_p;
case LIT_RECORD_TYPE_CHARSET:
{
const size_t str_size = lit_charset_literal_get_size (lit);
memcpy (buff_p, lit_charset_literal_get_charset (lit), (size > str_size) ? str_size : size);
return buff_p;
}
case LIT_RECORD_TYPE_MAGIC_STR:
{
return lit_get_magic_string_utf8 (lit_magic_literal_get_magic_str_id (lit));
}
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
return lit_get_magic_string_ex_utf8 (lit_magic_literal_get_magic_str_ex_id (lit));
}
case LIT_RECORD_TYPE_NUMBER:
{
ecma_number_t number = lit_number_literal_get_number (lit);
ecma_number_to_utf8_string (number, buff_p, (ssize_t) size);
return buff_p;
}
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
{
return lit_get_magic_string_utf8 (rcs_record_get_magic_str_id (lit));
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
{
return lit_get_magic_string_ex_utf8 (rcs_record_get_magic_str_ex_id (lit));
}
else
{
JERRY_ASSERT (RCS_RECORD_TYPE_IS_NUMBER (type));
ecma_number_t number = rcs_record_get_number (&rcs_lit_storage, lit);
ecma_number_to_utf8_string (number, buff_p, (ssize_t) size);
return buff_p;
}
JERRY_UNREACHABLE ();
} /* lit_literal_to_utf8_string */
/**
@ -548,9 +588,9 @@ lit_literal_exists (lit_literal_t lit) /**< literal to check for existence */
{
lit_literal_t current_lit;
for (current_lit = rcs_record_get_first (&rcs_lit_storage);
for (current_lit = lit_storage;
current_lit != NULL;
current_lit = rcs_record_get_next (&rcs_lit_storage, current_lit))
current_lit = lit_cpointer_decompress (current_lit->next))
{
if (current_lit == lit)
{
@ -567,10 +607,9 @@ lit_literal_exists (lit_literal_t lit) /**< literal to check for existence */
* @return literal
*/
lit_literal_t
lit_get_literal_by_cp (rcs_cpointer_t lit_cp) /**< compressed pointer to literal */
lit_get_literal_by_cp (lit_cpointer_t lit_cp) /**< compressed pointer to literal */
{
JERRY_ASSERT (lit_cp.u.packed_value != MEM_CP_NULL);
lit_literal_t lit = rcs_cpointer_decompress (lit_cp);
lit_literal_t lit = lit_cpointer_decompress (lit_cp);
JERRY_ASSERT (lit_literal_exists (lit));
return lit;
@ -579,25 +618,41 @@ lit_get_literal_by_cp (rcs_cpointer_t lit_cp) /**< compressed pointer to literal
lit_string_hash_t
lit_charset_literal_get_hash (lit_literal_t lit) /**< literal */
{
return rcs_record_get_hash (lit);
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_CHARSET);
const lit_charset_record_t *const rec_p = (const lit_charset_record_t *) lit;
return (lit_string_hash_t) rec_p->hash;
} /* lit_charset_literal_get_hash */
lit_magic_string_id_t
lit_magic_literal_get_magic_str_id (lit_literal_t lit) /**< literal */
{
return rcs_record_get_magic_str_id (lit);
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_MAGIC_STR);
const lit_magic_record_t *const rec_p = (const lit_magic_record_t *) lit;
return (lit_magic_string_id_t) rec_p->magic_id;
} /* lit_magic_literal_get_magic_str_id */
lit_magic_string_ex_id_t
lit_magic_literal_ex_get_magic_str_id (lit_literal_t lit) /**< literal */
lit_magic_literal_get_magic_str_ex_id (lit_literal_t lit) /**< literal */
{
return rcs_record_get_magic_str_ex_id (lit);
} /* lit_magic_literal_ex_get_magic_str_id */
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_MAGIC_STR_EX);
lit_utf8_size_t
const lit_magic_record_t *const rec_p = (const lit_magic_record_t *) lit;
return (lit_magic_string_ex_id_t) rec_p->magic_id;
} /* lit_magic_literal_get_magic_str_ex_id */
lit_utf8_size_t __attr_always_inline___ __attr_pure___
lit_charset_literal_get_size (lit_literal_t lit) /**< literal */
{
return rcs_record_get_length (lit);
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_CHARSET);
const lit_charset_record_t *const rec_p = (const lit_charset_record_t *) lit;
return (lit_utf8_size_t) rec_p->size;
} /* lit_charset_literal_get_size */
/**
@ -605,41 +660,32 @@ lit_charset_literal_get_size (lit_literal_t lit) /**< literal */
*
* @return code units count
*/
ecma_length_t
ecma_length_t __attr_always_inline___ __attr_pure___
lit_charset_literal_get_length (lit_literal_t lit) /**< literal */
{
TODO ("Add special case for literals which doesn't contain long characters");
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_CHARSET);
rcs_iterator_t it_ctx = rcs_iterator_create (&rcs_lit_storage, lit);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
const lit_charset_record_t *const rec_p = (const lit_charset_record_t *) lit;
lit_utf8_size_t lit_utf8_str_size = rcs_record_get_length (lit);
ecma_length_t length = 0;
lit_utf8_size_t i = 0;
while (i < lit_utf8_str_size)
{
lit_utf8_byte_t byte;
lit_utf8_size_t bytes_to_skip;
rcs_iterator_read (&it_ctx, &byte, sizeof (lit_utf8_byte_t));
bytes_to_skip = lit_get_unicode_char_size_by_utf8_first_byte (byte);
rcs_iterator_skip (&it_ctx, bytes_to_skip);
i += bytes_to_skip;
length++;
}
#ifndef JERRY_NDEBUG
rcs_iterator_skip (&it_ctx, rcs_record_get_alignment_bytes_count (lit));
JERRY_ASSERT (rcs_iterator_finished (&it_ctx));
#endif
return length;
return (ecma_length_t) rec_p->length;
} /* lit_charset_literal_get_length */
ecma_number_t
ecma_number_t __attr_always_inline___ __attr_pure___
lit_number_literal_get_number (lit_literal_t lit) /**< literal */
{
return rcs_record_get_number (&rcs_lit_storage, lit);
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_NUMBER);
const lit_number_record_t *const rec_p = (const lit_number_record_t *) lit;
return rec_p->number;
} /* lit_number_literal_get_number */
lit_utf8_byte_t * __attr_always_inline___ __attr_pure___
lit_charset_literal_get_charset (lit_literal_t lit) /**< literal */
{
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_CHARSET);
const lit_charset_record_t *const rec_p = (const lit_charset_record_t *) lit;
return (lit_utf8_byte_t *) (rec_p + 1);
} /* lit_charset_literal_get_charset */

20
jerry-core/lit/lit-literal.h
View File

@ -1,4 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,10 +18,18 @@
#define LIT_LITERAL_H
#include "ecma-globals.h"
#include "lit-globals.h"
#include "lit-literal-storage.h"
#include "lit-cpointer.h"
extern void lit_init (void);
extern void lit_finalize (void);
extern void lit_dump_literals (void);
/**
* Invalid literal
*/
#define NOT_A_LITERAL (lit_cpointer_null_cp ())
extern void lit_init ();
extern void lit_finalize ();
extern void lit_dump_literals ();
extern lit_literal_t lit_create_literal_from_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
extern lit_literal_t lit_find_literal_by_utf8_string (const lit_utf8_byte_t *, lit_utf8_size_t);
@ -38,6 +47,7 @@ extern bool lit_literal_equal_type_utf8 (lit_literal_t, const lit_utf8_byte_t *,
extern bool lit_literal_equal_type_cstr (lit_literal_t, const char *);
extern bool lit_literal_equal_type_num (lit_literal_t, ecma_number_t);
extern bool lit_literal_equal_type (lit_literal_t, lit_literal_t);
extern bool lit_literal_equal_charset (lit_literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
extern const lit_utf8_byte_t *lit_literal_to_utf8_string (lit_literal_t, lit_utf8_byte_t *, size_t);
extern const char *lit_literal_to_str_internal_buf (lit_literal_t);
@ -48,8 +58,10 @@ extern ecma_number_t lit_number_literal_get_number (lit_literal_t);
extern lit_string_hash_t lit_charset_literal_get_hash (lit_literal_t);
extern lit_utf8_size_t lit_charset_literal_get_size (lit_literal_t);
extern ecma_length_t lit_charset_literal_get_length (lit_literal_t);
extern lit_utf8_byte_t *lit_charset_literal_get_charset (lit_literal_t);
extern lit_literal_t lit_literal_get_next (lit_literal_t);
extern lit_magic_string_id_t lit_magic_literal_get_magic_str_id (lit_literal_t);
extern lit_magic_string_ex_id_t lit_magic_literal_ex_get_magic_str_id (lit_literal_t);
extern lit_magic_string_ex_id_t lit_magic_literal_get_magic_str_ex_id (lit_literal_t);
#endif /* LIT_LITERAL_H */

175
jerry-core/lit/lit-snapshot.c
View File

@ -1,5 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -18,9 +18,6 @@
#include "lit-literal.h"
#include "lit-literal-storage.h"
#include "rcs-allocator.h"
#include "rcs-iterator.h"
#include "rcs-records.h"
#ifdef JERRY_ENABLE_SNAPSHOT_SAVE
@ -36,91 +33,87 @@ lit_snapshot_dump (lit_literal_t lit, /**< literal to dump */
size_t buffer_size, /**< buffer size */
size_t *in_out_buffer_offset_p) /**< in-out: buffer write offset */
{
rcs_record_type_t record_type = rcs_record_get_type (lit);
if (RCS_RECORD_TYPE_IS_NUMBER (record_type))
const lit_record_type_t record_type = (lit_record_type_t) lit->type;
switch (record_type)
{
double num_value = rcs_record_get_number (&rcs_lit_storage, lit);
size_t size = sizeof (num_value);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&num_value,
size))
case LIT_RECORD_TYPE_CHARSET:
{
return 0;
}
return (uint32_t) size;
}
if (RCS_RECORD_TYPE_IS_CHARSET (record_type))
{
lit_utf8_size_t length = rcs_record_get_length (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&length,
sizeof (length)))
{
return 0;
}
rcs_iterator_t it_ctx = rcs_iterator_create (&rcs_lit_storage, lit);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t i;
for (i = 0; i < length; ++i)
{
lit_utf8_byte_t next_byte;
rcs_iterator_read (&it_ctx, &next_byte, sizeof (lit_utf8_byte_t));
const lit_charset_record_t *const rec_p = (const lit_charset_record_t *) lit;
lit_utf8_size_t size = lit_charset_literal_get_size (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&next_byte,
sizeof (next_byte)))
&size,
sizeof (size)))
{
return 0;
}
rcs_iterator_skip (&it_ctx, sizeof (lit_utf8_byte_t));
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
(void *) (rec_p + 1),
size))
{
return 0;
}
return (uint32_t) (sizeof (uint32_t) + size * sizeof (uint8_t));
}
return (uint32_t) (sizeof (uint32_t) + length * sizeof (uint8_t));
}
if (RCS_RECORD_TYPE_IS_MAGIC_STR (record_type))
{
lit_magic_string_id_t id = rcs_record_get_magic_str_id (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&id,
sizeof (id)))
case LIT_RECORD_TYPE_NUMBER:
{
return 0;
double num_value = lit_number_literal_get_number (lit);
const size_t size = sizeof (num_value);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&num_value,
size))
{
return 0;
}
return (uint32_t) size;
}
return (uint32_t) sizeof (lit_magic_string_id_t);
}
if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (record_type))
{
lit_magic_string_ex_id_t id = rcs_record_get_magic_str_ex_id (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&id,
sizeof (id)))
case LIT_RECORD_TYPE_MAGIC_STR:
{
return 0;
}
lit_magic_string_id_t id = lit_magic_literal_get_magic_str_id (lit);
return (uint32_t) sizeof (lit_magic_string_ex_id_t);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&id,
sizeof (id)))
{
return 0;
}
return (uint32_t) sizeof (lit_magic_string_id_t);
}
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t id = lit_magic_literal_get_magic_str_ex_id (lit);
if (!jrt_write_to_buffer_by_offset (buffer_p,
buffer_size,
in_out_buffer_offset_p,
&id,
sizeof (id)))
{
return 0;
}
return (uint32_t) sizeof (lit_magic_string_ex_id_t);
}
default:
{
JERRY_UNREACHABLE ();
break;
}
}
JERRY_UNREACHABLE ();
@ -143,7 +136,7 @@ lit_dump_literals_for_snapshot (uint8_t *buffer_p, /**< output snapshot buffer *
uint32_t *out_map_num_p, /**< out: number of literals */
uint32_t *out_lit_table_size_p) /**< out: number of bytes, dumped to snapshot buffer */
{
uint32_t literals_num = lit_storage_count_literals (&rcs_lit_storage);
uint32_t literals_num = lit_count_literals ();
uint32_t lit_table_size = 0;
*out_map_p = NULL;
@ -167,18 +160,18 @@ lit_dump_literals_for_snapshot (uint8_t *buffer_p, /**< output snapshot buffer *
size_t id_map_size = sizeof (lit_mem_to_snapshot_id_map_entry_t) * literals_num;
lit_mem_to_snapshot_id_map_entry_t *id_map_p;
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block (id_map_size, MEM_HEAP_ALLOC_SHORT_TERM);
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block_store_size (id_map_size);
uint32_t literal_index = 0;
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
for (lit = lit_storage;
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
lit = lit_cpointer_decompress (lit->next))
{
rcs_record_type_t record_type = rcs_record_get_type (lit);
lit_record_type_t record_type = (lit_record_type_t) lit->type;
if (RCS_RECORD_TYPE_IS_FREE (record_type))
if (record_type == LIT_RECORD_TYPE_FREE)
{
continue;
}
@ -202,7 +195,7 @@ lit_dump_literals_for_snapshot (uint8_t *buffer_p, /**< output snapshot buffer *
break;
}
rcs_cpointer_t lit_cp = rcs_cpointer_compress (lit);
lit_cpointer_t lit_cp = lit_cpointer_compress (lit);
id_map_p[literal_index].literal_id = lit_cp;
id_map_p[literal_index].literal_offset = lit_table_size;
@ -214,7 +207,7 @@ lit_dump_literals_for_snapshot (uint8_t *buffer_p, /**< output snapshot buffer *
if (!is_ok)
{
mem_heap_free_block (id_map_p);
mem_heap_free_block_size_stored (id_map_p);
return false;
}
@ -291,7 +284,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
size_t id_map_size = sizeof (lit_mem_to_snapshot_id_map_entry_t) * literals_num;
lit_mem_to_snapshot_id_map_entry_t *id_map_p;
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block (id_map_size, MEM_HEAP_ALLOC_SHORT_TERM);
id_map_p = (lit_mem_to_snapshot_id_map_entry_t *) mem_heap_alloc_block_store_size (id_map_size);
bool is_ok = true;
uint32_t lit_index;
@ -301,7 +294,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
uint32_t offset = (uint32_t) lit_table_read;
JERRY_ASSERT (offset == lit_table_read);
rcs_record_type_t type;
lit_record_type_t type;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
lit_table_size,
&lit_table_read,
@ -314,7 +307,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
lit_literal_t lit;
if (RCS_RECORD_TYPE_IS_CHARSET (type))
if (type == LIT_RECORD_TYPE_CHARSET)
{
lit_utf8_size_t length;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
@ -331,7 +324,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
lit = (lit_literal_t) lit_find_or_create_literal_from_utf8_string (lit_table_p + lit_table_read, length);
lit_table_read += length;
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
else if (type == LIT_RECORD_TYPE_MAGIC_STR)
{
lit_magic_string_id_t id;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
@ -353,7 +346,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
*/
lit = (lit_literal_t) lit_find_or_create_literal_from_utf8_string (magic_str_p, magic_str_sz);
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
else if (type == LIT_RECORD_TYPE_MAGIC_STR_EX)
{
lit_magic_string_ex_id_t id;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
@ -375,7 +368,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
*/
lit = (lit_literal_t) lit_find_or_create_literal_from_utf8_string (magic_str_ex_p, magic_str_ex_sz);
}
else if (RCS_RECORD_TYPE_IS_NUMBER (type))
else if (type == LIT_RECORD_TYPE_NUMBER)
{
double num;
if (!jrt_read_from_buffer_by_offset (lit_table_p,
@ -397,7 +390,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
}
id_map_p[lit_index].literal_offset = offset;
id_map_p[lit_index].literal_id = rcs_cpointer_compress (lit);
id_map_p[lit_index].literal_id = lit_cpointer_compress (lit);
}
if (is_ok)
@ -408,7 +401,7 @@ lit_load_literals_from_snapshot (const uint8_t *lit_table_p, /**< buffer with li
return true;
}
mem_heap_free_block (id_map_p);
mem_heap_free_block_size_stored (id_map_p);
return false;
} /* lit_load_literals_from_snapshot */

7
jerry-core/lit/lit-snapshot.h
View File

@ -1,5 +1,5 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,11 +17,12 @@
#ifndef RCS_SNAPSHOT_H
#define RCS_SNAPSHOT_H
#include "rcs-cpointer.h"
#include "lit-cpointer.h"
#include "ecma-globals.h"
typedef struct
{
rcs_cpointer_t literal_id;
lit_cpointer_t literal_id;
uint32_t literal_offset;
} lit_mem_to_snapshot_id_map_entry_t;

16
jerry-core/mem/mem-allocator.c
View File

@ -1,4 +1,5 @@
/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -143,23 +144,22 @@ mem_stats_reset_peak (void)
void
mem_stats_print (void)
{
mem_heap_stats_print ();
mem_heap_print ();
mem_pools_stats_t stats;
mem_pools_get_stats (&stats);
printf ("Pools stats:\n");
printf (" Chunk size: %zu\n"
" Pools: %zu\n"
" Allocated chunks: %zu\n"
" Pool chunks: %zu\n"
" Peak pool chunks: %zu\n"
" Free chunks: %zu\n"
" Peak pools: %zu\n"
" Peak allocated chunks: %zu\n\n",
" Pool reuse ratio: %zu.%04zu\n",
MEM_POOL_CHUNK_SIZE,
stats.pools_count,
stats.allocated_chunks,
stats.free_chunks,
stats.peak_pools_count,
stats.peak_allocated_chunks);
stats.free_chunks,
stats.reused_count / stats.new_alloc_count,
stats.reused_count % stats.new_alloc_count * 10000 / stats.new_alloc_count);
} /* mem_stats_print */
#endif /* MEM_STATS */

5
jerry-core/mem/mem-allocator.h
View File

@ -43,6 +43,11 @@ typedef uint16_t mem_cpointer_t;
*/
#define MEM_ALIGNMENT (1u << MEM_ALIGNMENT_LOG)
/**
* Required alignment for allocated units/blocks
*/
#define MEM_POOL_ALIGNMENT (1 << MEM_POOL_ALIGNMENT_LOG)
/**
* Width of compressed memory pointer
*/

5
jerry-core/mem/mem-config.h
View File

@ -43,4 +43,9 @@
*/
#define MEM_ALIGNMENT_LOG 3
/**
* Logarithm of required alignment for allocated pools
*/
#define MEM_POOL_ALIGNMENT_LOG 3
#endif /* MEM_CONFIG_H */

1054
jerry-core/mem/mem-heap.c
View File

File diff suppressed because it is too large Load Diff

44
jerry-core/mem/mem-heap.h
View File

@ -1,4 +1,5 @@
/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -28,29 +29,18 @@
#include "jrt.h"
/**
* Type of allocation (argument of mem_Alloc)
*
* @see mem_heap_alloc_block
*/
typedef enum
{
MEM_HEAP_ALLOC_SHORT_TERM, /**< allocated region will be freed soon */
MEM_HEAP_ALLOC_LONG_TERM /**< allocated region most likely will not be freed soon */
} mem_heap_alloc_term_t;
extern void mem_heap_init (void);
extern void mem_heap_finalize (void);
extern void *mem_heap_alloc_block (size_t, mem_heap_alloc_term_t);
extern void *mem_heap_alloc_chunked_block (mem_heap_alloc_term_t);
extern void mem_heap_free_block (void *);
extern void *mem_heap_get_chunked_block_start (void *);
extern size_t mem_heap_get_chunked_block_data_size (void);
extern void *mem_heap_alloc_block (const size_t);
extern void mem_heap_free_block (void *, const size_t);
extern void *mem_heap_alloc_block_store_size (size_t);
extern void mem_heap_free_block_size_stored (void *);
extern uintptr_t mem_heap_compress_pointer (const void *);
extern void *mem_heap_decompress_pointer (uintptr_t);
extern bool mem_is_heap_pointer (const void *);
extern size_t __attr_pure___ mem_heap_recommend_allocation_size (size_t);
extern void mem_heap_print (bool, bool, bool);
extern void mem_heap_print ();
#ifdef MEM_STATS
/**
@ -59,15 +49,6 @@ extern void mem_heap_print (bool, bool, bool);
typedef struct
{
size_t size; /**< size */
size_t blocks; /**< blocks count */
size_t allocated_chunks; /**< currently allocated chunks */
size_t peak_allocated_chunks; /**< peak allocated chunks */
size_t global_peak_allocated_chunks; /**< non-resettable peak allocated chunks */
size_t allocated_blocks; /**< currently allocated blocks */
size_t peak_allocated_blocks; /**< peak allocated blocks */
size_t global_peak_allocated_blocks; /**< non-resettable peak allocated blocks */
size_t allocated_bytes; /**< currently allocated bytes */
size_t peak_allocated_bytes; /**< peak allocated bytes */
@ -77,6 +58,15 @@ typedef struct
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 skip_count;
size_t nonskip_count;
size_t alloc_count;
size_t alloc_iter_count;
size_t free_count;
size_t free_iter_count;
} mem_heap_stats_t;
extern void mem_heap_get_stats (mem_heap_stats_t *);
@ -111,7 +101,7 @@ extern void mem_heap_valgrind_freya_mempool_request (void);
#define MEM_DEFINE_LOCAL_ARRAY(var_name, number, type) \
{ \
size_t var_name ## ___size = (size_t) (number) * sizeof (type); \
type *var_name = (type *) (mem_heap_alloc_block (var_name ## ___size, MEM_HEAP_ALLOC_SHORT_TERM));
type *var_name = (type *) (mem_heap_alloc_block (var_name ## ___size));
/**
* Free the previously defined local array variable, freeing corresponding block on the heap,
@ -122,7 +112,7 @@ extern void mem_heap_valgrind_freya_mempool_request (void);
{ \
JERRY_ASSERT (var_name ## ___size != 0); \
\
mem_heap_free_block (var_name); \
mem_heap_free_block (var_name, var_name ## ___size); \
} \
else \
{ \

689
jerry-core/mem/mem-poolman.c
View File

@ -35,117 +35,45 @@
#include "mem-allocator-internal.h"
/**
* Size of a pool
* Node for free chunk list
*/
#define MEM_POOL_SIZE (mem_heap_get_chunked_block_data_size ())
/**
* Number of chunks in a pool
*/
#define MEM_POOL_CHUNKS_NUMBER (MEM_POOL_SIZE / MEM_POOL_CHUNK_SIZE)
#ifndef JERRY_NDEBUG
size_t mem_free_chunks_number;
#endif /* !JERRY_NDEBUG */
/**
* Index of chunk in a pool
*/
typedef uint8_t mem_pool_chunk_index_t;
/**
* Type for mem_pool_chunk
*/
typedef struct mem_pool_chunk mem_pool_chunk_t;
/**
* Pool chunk
*/
struct mem_pool_chunk
typedef struct
{
/**
* Union of possible free chunk layouts
*
* Allocated chunk represents raw data of MEM_POOL_CHUNK_SIZE bytes,
* and so, has no fixed layout.
*/
union
{
/**
* Structure of free pool chunks that are:
* - first in corresponding pool, while empty pool collector is not active;
* - not first in corresponding pool.
*/
struct
{
mem_pool_chunk_t *next_p; /**< global list of free pool chunks */
} free;
/**
* While empty pool collector is active, the following structure is used
* for first chunks of pools, in which first chunks are free
*
* See also:
* mem_pools_collect_empty
*/
struct
{
mem_cpointer_t next_first_cp; /**< list of first free chunks of
* pools with free first chunks */
mem_cpointer_t free_list_cp; /**< list of free chunks
* in the pool containing this chunk */
uint16_t hint_magic_num; /**< magic number that hints whether
* there is a probability that the chunk
* is an item (header) in a pool list */
mem_pool_chunk_index_t free_chunks_num; /**< number of free chunks
* in the pool containing this chunk */
uint8_t traversal_check_flag; /**< flag that is flipped between two non-first chunk lists traversals
* to determine whether the corresponding pool-first chunks are actually free */
} pool_gc;
/**
* The field is added to make sizeof (mem_pool_chunk_t) equal to MEM_POOL_CHUNK_SIZE
*/
uint8_t allocated_area[MEM_POOL_CHUNK_SIZE];
} u;
} mem_pool_chunk;
/**
* The condition is assumed when using pointer arithmetics on (mem_pool_chunk_t *) pointer type
*/
JERRY_STATIC_ASSERT (sizeof (mem_pool_chunk_t) == MEM_POOL_CHUNK_SIZE,
size_of_mem_pool_chunk_t_must_be_equal_to_MEM_POOL_CHUNK_SIZE);
struct mem_pools_chunk_t *next_p; /* pointer to next pool chunk */
#ifndef MEM_HEAP_PTR_64
uint32_t dummy; /* dummy member for alignment */
#endif
} mem_pools_chunk_t;
/**
* List of free pool chunks
*/
mem_pool_chunk_t *mem_free_chunk_p;
static void mem_check_pools (void);
mem_pools_chunk_t *mem_free_chunk_p;
#ifdef MEM_STATS
/**
* Pools' memory usage statistics
*/
mem_pools_stats_t mem_pools_stats;
static void mem_pools_stat_init (void);
static void mem_pools_stat_alloc_pool (void);
static void mem_pools_stat_free_pool (void);
static void mem_pools_stat_alloc_chunk (void);
static void mem_pools_stat_free_chunk (void);
static void mem_pools_stat_new_alloc (void);
static void mem_pools_stat_reuse (void);
static void mem_pools_stat_dealloc (void);
# define MEM_POOLS_STAT_INIT() mem_pools_stat_init ()
# define MEM_POOLS_STAT_ALLOC_POOL() mem_pools_stat_alloc_pool ()
# define MEM_POOLS_STAT_FREE_POOL() mem_pools_stat_free_pool ()
# define MEM_POOLS_STAT_ALLOC_CHUNK() mem_pools_stat_alloc_chunk ()
# define MEM_POOLS_STAT_FREE_CHUNK() mem_pools_stat_free_chunk ()
# define MEM_POOLS_STAT_NEW_ALLOC() mem_pools_stat_new_alloc ()
# define MEM_POOLS_STAT_REUSE() mem_pools_stat_reuse ()
# define MEM_POOLS_STAT_DEALLOC() mem_pools_stat_dealloc ()
#else /* !MEM_STATS */
# define MEM_POOLS_STAT_INIT()
# define MEM_POOLS_STAT_ALLOC_POOL()
# define MEM_POOLS_STAT_FREE_POOL()
# define MEM_POOLS_STAT_ALLOC_CHUNK()
# define MEM_POOLS_STAT_FREE_CHUNK()
# define MEM_POOLS_STAT_NEW_ALLOC()
# define MEM_POOLS_STAT_REUSE()
# define MEM_POOLS_STAT_DEALLOC()
#endif /* !MEM_STATS */
/*
@ -179,9 +107,8 @@ static void mem_pools_stat_free_chunk (void);
void
mem_pools_init (void)
{
#ifndef JERRY_NDEBUG
mem_free_chunks_number = 0;
#endif /* !JERRY_NDEBUG */
JERRY_STATIC_ASSERT (sizeof (mem_pools_chunk_t) == MEM_POOL_CHUNK_SIZE,
size_of_mem_pool_chunk_t_must_be_equal_to_MEM_POOL_CHUNK_SIZE);
mem_free_chunk_p = NULL;
@ -196,423 +123,8 @@ mem_pools_finalize (void)
{
mem_pools_collect_empty ();
#ifndef JERRY_NDEBUG
JERRY_ASSERT (mem_free_chunks_number == 0);
#endif /* !JERRY_NDEBUG */
} /* mem_pools_finalize */
/**
* Helper for reading magic number and traversal check flag fields of a pool-first chunk,
* that suppresses valgrind's warnings about undefined values.
*
* A pool-first chunk can be either allocated or free.
*
* As chunks are marked as undefined upon allocation, some of chunks can still be
* fully or partially marked as undefined.
*
* Nevertheless, the fields are read and their values are used to determine
* whether the chunk is actually free pool-first chunk.
*
* See also:
* Description of collection algorithm in mem_pools_collect_empty
*/
static void __attr_always_inline___
mem_pools_collect_read_magic_num_and_flag (mem_pool_chunk_t *pool_first_chunk_p, /**< a pool-first chunk */
uint16_t *out_magic_num_field_value_p, /**< out: value of magic num field,
* read from the chunk */
bool *out_traversal_check_flag_p) /**< out: value of traversal check flag
* field, read from the chunk */
{
JERRY_ASSERT (pool_first_chunk_p != NULL);
JERRY_ASSERT (out_magic_num_field_value_p != NULL);
JERRY_ASSERT (out_traversal_check_flag_p != NULL);
#ifdef JERRY_VALGRIND
/*
* If the chunk is not free, there may be undefined bytes at hint_magic_num and traversal_check_flag fields.
*
* Although, it is correct for the routine, valgrind issues warning about using uninitialized data
* in conditional expression. To suppress the false-positive warning, the chunk is temporarily marked
* as defined, and after reading hint magic number and list identifier, valgrind state of the chunk is restored.
*/
uint8_t vbits[MEM_POOL_CHUNK_SIZE];
unsigned status;
status = VALGRIND_GET_VBITS (pool_first_chunk_p, vbits, MEM_POOL_CHUNK_SIZE);
JERRY_ASSERT (status == 0 || status == 1);
VALGRIND_DEFINED_SPACE (pool_first_chunk_p, MEM_POOL_CHUNK_SIZE);
#endif /* JERRY_VALGRIND */
uint16_t magic_num_field = pool_first_chunk_p->u.pool_gc.hint_magic_num;
bool traversal_check_flag = pool_first_chunk_p->u.pool_gc.traversal_check_flag;
#ifdef JERRY_VALGRIND
status = VALGRIND_SET_VBITS (pool_first_chunk_p, vbits, MEM_POOL_CHUNK_SIZE);
JERRY_ASSERT (status == 0 || status == 1);
#endif /* JERRY_VALGRIND */
*out_magic_num_field_value_p = magic_num_field;
*out_traversal_check_flag_p = traversal_check_flag;
} /* mem_pools_collect_read_magic_num_and_flag */
/**
* Collect chunks from empty pools and free the pools
*/
void
mem_pools_collect_empty (void)
{
/*
* Hint magic number in header of pools with free pool-first chunks
*/
const uint16_t hint_magic_num_value = 0x7e89;
/*
* Collection-time chunk lists
*/
mem_pool_chunk_t *first_chunks_list_p = NULL;
mem_pool_chunk_t *non_first_chunks_list_p = NULL;
/*
* At first stage collect free pool-first chunks to separate collection-time lists
* and change their layout from mem_pool_chunk_t::u::free to mem_pool_chunk_t::u::pool_gc
*/
{
mem_pool_chunk_t tmp_header;
tmp_header.u.free.next_p = mem_free_chunk_p;
for (mem_pool_chunk_t *free_chunk_iter_p = tmp_header.u.free.next_p,
*prev_free_chunk_p = &tmp_header,
*next_free_chunk_p;
free_chunk_iter_p != NULL;
free_chunk_iter_p = next_free_chunk_p)
{
mem_pool_chunk_t *pool_start_p = (mem_pool_chunk_t *) mem_heap_get_chunked_block_start (free_chunk_iter_p);
VALGRIND_DEFINED_SPACE (free_chunk_iter_p, MEM_POOL_CHUNK_SIZE);
next_free_chunk_p = free_chunk_iter_p->u.free.next_p;
if (pool_start_p == free_chunk_iter_p)
{
/*
* The chunk is first at its pool
*
* Remove the chunk from common list of free chunks
*/
prev_free_chunk_p->u.free.next_p = next_free_chunk_p;
/*
* Initialize pool-first chunk as pool header and it insert into list of free pool-first chunks
*/
free_chunk_iter_p->u.pool_gc.free_list_cp = MEM_CP_NULL;
free_chunk_iter_p->u.pool_gc.free_chunks_num = 1; /* the first chunk */
free_chunk_iter_p->u.pool_gc.hint_magic_num = hint_magic_num_value;
free_chunk_iter_p->u.pool_gc.traversal_check_flag = false;
MEM_CP_SET_POINTER (free_chunk_iter_p->u.pool_gc.next_first_cp, first_chunks_list_p);
first_chunks_list_p = free_chunk_iter_p;
}
else
{
prev_free_chunk_p = free_chunk_iter_p;
}
}
mem_free_chunk_p = tmp_header.u.free.next_p;
}
if (first_chunks_list_p == NULL)
{
/* there are no empty pools */
return;
}
/*
* At second stage we collect all free non-pool-first chunks, for which corresponding pool-first chunks are free,
* and link them into the corresponding mem_pool_chunk_t::u::pool_gc::free_list_cp list, while also maintaining
* the corresponding mem_pool_chunk_t::u::pool_gc::free_chunks_num:
* - at first, for each non-pool-first free chunk we check whether traversal check flag is cleared in corresponding
* first chunk in the same pool, and move those chunks, for which the condition is true,
* to separate temporary list.
*
* - then, we flip the traversal check flags for each of free pool-first chunks.
*
* - at last, we perform almost the same as at first step, but check only non-pool-first chunks from the temporary
* list, and send the chunks, for which the corresponding traversal check flag is cleared, back to the common list
* of free chunks, and the rest chunks from the temporary list are linked to corresponding pool-first chunks.
* Also, counter of the linked free chunks is maintained in every free pool-first chunk.
*/
{
{
mem_pool_chunk_t tmp_header;
tmp_header.u.free.next_p = mem_free_chunk_p;
for (mem_pool_chunk_t *free_chunk_iter_p = tmp_header.u.free.next_p,
*prev_free_chunk_p = &tmp_header,
*next_free_chunk_p;
free_chunk_iter_p != NULL;
free_chunk_iter_p = next_free_chunk_p)
{
mem_pool_chunk_t *pool_start_p = (mem_pool_chunk_t *) mem_heap_get_chunked_block_start (free_chunk_iter_p);
next_free_chunk_p = free_chunk_iter_p->u.free.next_p;
/*
* The magic number doesn't guarantee that the chunk is actually a free pool-first chunk,
* so we test the traversal check flag after flipping values of the flags in every
* free pool-first chunk.
*/
uint16_t magic_num_field;
bool traversal_check_flag;
mem_pools_collect_read_magic_num_and_flag (pool_start_p, &magic_num_field, &traversal_check_flag);
/*
* During this traversal the flag in the free header chunks is in cleared state
*/
if (!traversal_check_flag
&& magic_num_field == hint_magic_num_value)
{
free_chunk_iter_p->u.free.next_p = non_first_chunks_list_p;
non_first_chunks_list_p = free_chunk_iter_p;
prev_free_chunk_p->u.free.next_p = next_free_chunk_p;
}
else
{
prev_free_chunk_p = free_chunk_iter_p;
}
}
mem_free_chunk_p = tmp_header.u.free.next_p;
}
{
/*
* Now, flip the traversal check flag in free pool-first chunks
*/
for (mem_pool_chunk_t *first_chunks_iter_p = first_chunks_list_p;
first_chunks_iter_p != NULL;
first_chunks_iter_p = MEM_CP_GET_POINTER (mem_pool_chunk_t,
first_chunks_iter_p->u.pool_gc.next_first_cp))
{
JERRY_ASSERT (!first_chunks_iter_p->u.pool_gc.traversal_check_flag);
first_chunks_iter_p->u.pool_gc.traversal_check_flag = true;
}
}
{
for (mem_pool_chunk_t *non_first_chunks_iter_p = non_first_chunks_list_p, *next_p;
non_first_chunks_iter_p != NULL;
non_first_chunks_iter_p = next_p)
{
next_p = non_first_chunks_iter_p->u.free.next_p;
mem_pool_chunk_t *pool_start_p;
pool_start_p = (mem_pool_chunk_t *) mem_heap_get_chunked_block_start (non_first_chunks_iter_p);
uint16_t magic_num_field;
bool traversal_check_flag;
mem_pools_collect_read_magic_num_and_flag (pool_start_p, &magic_num_field, &traversal_check_flag);
JERRY_ASSERT (magic_num_field == hint_magic_num_value);
#ifndef JERRY_DISABLE_HEAVY_DEBUG
bool is_occured = false;
for (mem_pool_chunk_t *first_chunks_iter_p = first_chunks_list_p;
first_chunks_iter_p != NULL;
first_chunks_iter_p = MEM_CP_GET_POINTER (mem_pool_chunk_t,
first_chunks_iter_p->u.pool_gc.next_first_cp))
{
if (pool_start_p == first_chunks_iter_p)
{
is_occured = true;
break;
}
}
JERRY_ASSERT (is_occured == traversal_check_flag);
#endif /* !JERRY_DISABLE_HEAVY_DEBUG */
/*
* During this traversal the flag in the free header chunks is in set state
*
* If the flag is set, it is guaranteed that the pool-first chunk,
* from the same pool, as the current non-pool-first chunk, is free
* and is placed in the corresponding list of free pool-first chunks.
*/
if (traversal_check_flag)
{
pool_start_p->u.pool_gc.free_chunks_num++;
non_first_chunks_iter_p->u.free.next_p = MEM_CP_GET_POINTER (mem_pool_chunk_t,
pool_start_p->u.pool_gc.free_list_cp);
MEM_CP_SET_NON_NULL_POINTER (pool_start_p->u.pool_gc.free_list_cp, non_first_chunks_iter_p);
}
else
{
non_first_chunks_iter_p->u.free.next_p = mem_free_chunk_p;
mem_free_chunk_p = non_first_chunks_iter_p;
}
}
}
non_first_chunks_list_p = NULL;
}
/*
* At third stage we check each free pool-first chunk in collection-time list for counted
* number of free chunks in the pool, containing the chunk.
*
* If the number is equal to number of chunks in the pool - then the pool is empty, and so is freed,
* otherwise - free chunks of the pool are returned to the common list of free chunks.
*/
for (mem_pool_chunk_t *first_chunks_iter_p = first_chunks_list_p, *next_p;
first_chunks_iter_p != NULL;
first_chunks_iter_p = next_p)
{
next_p = MEM_CP_GET_POINTER (mem_pool_chunk_t,
first_chunks_iter_p->u.pool_gc.next_first_cp);
JERRY_ASSERT (first_chunks_iter_p->u.pool_gc.hint_magic_num == hint_magic_num_value);
JERRY_ASSERT (first_chunks_iter_p->u.pool_gc.traversal_check_flag);
JERRY_ASSERT (first_chunks_iter_p->u.pool_gc.free_chunks_num <= MEM_POOL_CHUNKS_NUMBER);
if (first_chunks_iter_p->u.pool_gc.free_chunks_num == MEM_POOL_CHUNKS_NUMBER)
{
#ifndef JERRY_NDEBUG
mem_free_chunks_number -= MEM_POOL_CHUNKS_NUMBER;
#endif /* !JERRY_NDEBUG */
MEM_HEAP_VALGRIND_FREYA_MEMPOOL_REQUEST ();
mem_heap_free_block (first_chunks_iter_p);
MEM_POOLS_STAT_FREE_POOL ();
}
else
{
mem_pool_chunk_t *first_chunk_p = first_chunks_iter_p;
/*
* Convert layout of first chunk from collection-time pool-first chunk's layout to the common free chunk layout
*/
first_chunk_p->u.free.next_p = MEM_CP_GET_POINTER (mem_pool_chunk_t,
first_chunks_iter_p->u.pool_gc.free_list_cp);
/*
* Link local pool's list of free chunks into the common list of free chunks
*/
for (mem_pool_chunk_t *pool_chunks_iter_p = first_chunk_p;
;
pool_chunks_iter_p = pool_chunks_iter_p->u.free.next_p)
{
JERRY_ASSERT (pool_chunks_iter_p != NULL);
if (pool_chunks_iter_p->u.free.next_p == NULL)
{
pool_chunks_iter_p->u.free.next_p = mem_free_chunk_p;
break;
}
}
mem_free_chunk_p = first_chunk_p;
}
}
#ifdef JERRY_VALGRIND
/*
* Valgrind-mode specific pass that marks all free chunks inaccessible
*/
for (mem_pool_chunk_t *free_chunk_iter_p = mem_free_chunk_p, *next_free_chunk_p;
free_chunk_iter_p != NULL;
free_chunk_iter_p = next_free_chunk_p)
{
next_free_chunk_p = free_chunk_iter_p->u.free.next_p;
VALGRIND_NOACCESS_SPACE (free_chunk_iter_p, MEM_POOL_CHUNK_SIZE);
}
#endif /* JERRY_VALGRIND */
} /* mem_pools_collect_empty */
/**
* Long path for mem_pools_alloc
*/
static void __attr_noinline___
mem_pools_alloc_longpath (void)
{
mem_check_pools ();
JERRY_ASSERT (mem_free_chunk_p == NULL);
JERRY_ASSERT (MEM_POOL_SIZE <= mem_heap_get_chunked_block_data_size ());
JERRY_ASSERT (MEM_POOL_CHUNKS_NUMBER >= 1);
MEM_HEAP_VALGRIND_FREYA_MEMPOOL_REQUEST ();
mem_pool_chunk_t *pool_start_p = (mem_pool_chunk_t *) mem_heap_alloc_chunked_block (MEM_HEAP_ALLOC_LONG_TERM);
if (mem_free_chunk_p != NULL)
{
/* some chunks were freed due to GC invoked by heap allocator */
MEM_HEAP_VALGRIND_FREYA_MEMPOOL_REQUEST ();
mem_heap_free_block (pool_start_p);
return;
}
#ifndef JERRY_NDEBUG
mem_free_chunks_number += MEM_POOL_CHUNKS_NUMBER;
#endif /* !JERRY_NDEBUG */
JERRY_STATIC_ASSERT (MEM_POOL_CHUNK_SIZE % MEM_ALIGNMENT == 0,
MEM_POOL_CHUNK_SIZE_must_be_multiple_of_MEM_ALIGNMENT);
JERRY_STATIC_ASSERT (sizeof (mem_pool_chunk_index_t) <= MEM_POOL_CHUNK_SIZE,
size_of_mem_pool_chunk_index_t_must_be_less_than_or_equal_to_MEM_POOL_CHUNK_SIZE);
JERRY_ASSERT ((mem_pool_chunk_index_t) MEM_POOL_CHUNKS_NUMBER == MEM_POOL_CHUNKS_NUMBER);
JERRY_ASSERT (MEM_POOL_SIZE == MEM_POOL_CHUNKS_NUMBER * MEM_POOL_CHUNK_SIZE);
JERRY_ASSERT (((uintptr_t) pool_start_p) % MEM_ALIGNMENT == 0);
mem_pool_chunk_t *prev_free_chunk_p = NULL;
for (mem_pool_chunk_index_t chunk_index = 0;
chunk_index < MEM_POOL_CHUNKS_NUMBER;
chunk_index++)
{
mem_pool_chunk_t *chunk_p = pool_start_p + chunk_index;
if (prev_free_chunk_p != NULL)
{
prev_free_chunk_p->u.free.next_p = chunk_p;
}
prev_free_chunk_p = chunk_p;
}
prev_free_chunk_p->u.free.next_p = NULL;
#ifdef JERRY_VALGRIND
for (mem_pool_chunk_index_t chunk_index = 0;
chunk_index < MEM_POOL_CHUNKS_NUMBER;
chunk_index++)
{
mem_pool_chunk_t *chunk_p = pool_start_p + chunk_index;
VALGRIND_NOACCESS_SPACE (chunk_p, MEM_POOL_CHUNK_SIZE);
}
#endif /* JERRY_VALGRIND */
mem_free_chunk_p = pool_start_p;
MEM_POOLS_STAT_ALLOC_POOL ();
mem_check_pools ();
} /* mem_pools_alloc_longpath */
} /* mem_pools_finalize */
/**
* Allocate a chunk of specified size
@ -620,99 +132,69 @@ mem_pools_alloc_longpath (void)
* @return pointer to allocated chunk, if allocation was successful,
* or NULL - if not enough memory.
*/
uint8_t *__attr_always_inline___
void * __attribute__((hot)) __attr_always_inline___
mem_pools_alloc (void)
{
#ifdef MEM_GC_BEFORE_EACH_ALLOC
mem_run_try_to_give_memory_back_callbacks (MEM_TRY_GIVE_MEMORY_BACK_SEVERITY_HIGH);
#endif /* MEM_GC_BEFORE_EACH_ALLOC */
mem_check_pools ();
do
if (mem_free_chunk_p != NULL)
{
if (mem_free_chunk_p != NULL)
{
mem_pool_chunk_t *chunk_p = mem_free_chunk_p;
const mem_pools_chunk_t *const chunk_p = mem_free_chunk_p;
MEM_POOLS_STAT_ALLOC_CHUNK ();
MEM_POOLS_STAT_REUSE ();
#ifndef JERRY_NDEBUG
mem_free_chunks_number--;
#endif /* !JERRY_NDEBUG */
VALGRIND_DEFINED_SPACE (chunk_p, MEM_POOL_CHUNK_SIZE);
VALGRIND_DEFINED_SPACE (chunk_p, MEM_POOL_CHUNK_SIZE);
mem_free_chunk_p = chunk_p->next_p;
mem_free_chunk_p = chunk_p->u.free.next_p;
VALGRIND_UNDEFINED_SPACE (chunk_p, MEM_POOL_CHUNK_SIZE);
VALGRIND_UNDEFINED_SPACE (chunk_p, MEM_POOL_CHUNK_SIZE);
mem_check_pools ();
VALGRIND_FREYA_MALLOCLIKE_SPACE (chunk_p, MEM_POOL_CHUNK_SIZE);
return (uint8_t *) chunk_p;
}
else
{
mem_pools_alloc_longpath ();
/* the assertion guarantees that there will be no more than two iterations */
JERRY_ASSERT (mem_free_chunk_p != NULL);
}
} while (true);
return (void *) chunk_p;
}
else
{
MEM_POOLS_STAT_NEW_ALLOC ();
return (void *) mem_heap_alloc_block (MEM_POOL_CHUNK_SIZE);
}
} /* mem_pools_alloc */
/**
* Free the chunk
*/
void __attr_always_inline___
mem_pools_free (uint8_t *chunk_p) /**< pointer to the chunk */
void __attribute__((hot))
mem_pools_free (void *chunk_p) /**< pointer to the chunk */
{
mem_check_pools ();
mem_pools_chunk_t *const chunk_to_free_p = (mem_pools_chunk_t *) chunk_p;
mem_pool_chunk_t *chunk_to_free_p = (mem_pool_chunk_t *) chunk_p;
VALGRIND_DEFINED_SPACE (chunk_to_free_p, MEM_POOL_CHUNK_SIZE);
chunk_to_free_p->u.free.next_p = mem_free_chunk_p;
chunk_to_free_p->next_p = mem_free_chunk_p;
mem_free_chunk_p = chunk_to_free_p;
VALGRIND_FREYA_FREELIKE_SPACE (chunk_to_free_p);
VALGRIND_NOACCESS_SPACE (chunk_to_free_p, MEM_POOL_CHUNK_SIZE);
#ifndef JERRY_NDEBUG
mem_free_chunks_number++;
#endif /* !JERRY_NDEBUG */
MEM_POOLS_STAT_FREE_CHUNK ();
mem_check_pools ();
MEM_POOLS_STAT_FREE_POOL ();
} /* mem_pools_free */
/**
* Check correctness of pool allocator state
* Collect empty pool chunks
*/
static void
mem_check_pools (void)
void
mem_pools_collect_empty ()
{
#ifndef JERRY_DISABLE_HEAVY_DEBUG
size_t free_chunks_met = 0;
for (mem_pool_chunk_t *free_chunk_iter_p = mem_free_chunk_p, *next_free_chunk_p;
free_chunk_iter_p != NULL;
free_chunk_iter_p = next_free_chunk_p)
while (mem_free_chunk_p)
{
VALGRIND_DEFINED_SPACE (free_chunk_iter_p, MEM_POOL_CHUNK_SIZE);
VALGRIND_DEFINED_SPACE (mem_free_chunk_p, sizeof (mem_pools_chunk_t));
mem_pools_chunk_t *const next_p = mem_free_chunk_p->next_p;
VALGRIND_NOACCESS_SPACE (mem_free_chunk_p, sizeof (mem_pools_chunk_t));
next_free_chunk_p = free_chunk_iter_p->u.free.next_p;
VALGRIND_NOACCESS_SPACE (free_chunk_iter_p, MEM_POOL_CHUNK_SIZE);
free_chunks_met++;
mem_heap_free_block (mem_free_chunk_p, MEM_POOL_CHUNK_SIZE);
MEM_POOLS_STAT_DEALLOC ();
mem_free_chunk_p = next_p;
}
JERRY_ASSERT (free_chunks_met == mem_free_chunks_number);
#endif /* !JERRY_DISABLE_HEAVY_DEBUG */
} /* mem_check_pools */
} /* mem_pools_collect_empty */
#ifdef MEM_STATS
/**
@ -733,7 +215,6 @@ void
mem_pools_stats_reset_peak (void)
{
mem_pools_stats.peak_pools_count = mem_pools_stats.pools_count;
mem_pools_stats.peak_allocated_chunks = mem_pools_stats.allocated_chunks;
} /* mem_pools_stats_reset_peak */
/**
@ -746,12 +227,13 @@ mem_pools_stat_init (void)
} /* mem_pools_stat_init */
/**
* Account allocation of a pool
* Account for allocation of new pool chunk
*/
static void
mem_pools_stat_alloc_pool (void)
mem_pools_stat_new_alloc (void)
{
mem_pools_stats.pools_count++;
mem_pools_stats.new_alloc_count++;
if (mem_pools_stats.pools_count > mem_pools_stats.peak_pools_count)
{
@ -761,57 +243,50 @@ mem_pools_stat_alloc_pool (void)
{
mem_pools_stats.global_peak_pools_count = mem_pools_stats.pools_count;
}
} /* mem_pools_stat_new_alloc */
mem_pools_stats.free_chunks += MEM_POOL_CHUNKS_NUMBER;
} /* mem_pools_stat_alloc_pool */
/**
* Account freeing of a pool
* Account for reuse of pool chunk
*/
static void
mem_pools_stat_reuse (void)
{
mem_pools_stats.pools_count++;
mem_pools_stats.free_chunks--;
mem_pools_stats.reused_count++;
if (mem_pools_stats.pools_count > mem_pools_stats.peak_pools_count)
{
mem_pools_stats.peak_pools_count = mem_pools_stats.pools_count;
}
if (mem_pools_stats.pools_count > mem_pools_stats.global_peak_pools_count)
{
mem_pools_stats.global_peak_pools_count = mem_pools_stats.pools_count;
}
} /* mem_pools_stat_reuse */
/**
* Account for freeing a chunk
*/
static void
mem_pools_stat_free_pool (void)
{
JERRY_ASSERT (mem_pools_stats.free_chunks >= MEM_POOL_CHUNKS_NUMBER);
mem_pools_stats.free_chunks -= MEM_POOL_CHUNKS_NUMBER;
JERRY_ASSERT (mem_pools_stats.pools_count > 0);
mem_pools_stats.pools_count--;
mem_pools_stats.free_chunks++;
} /* mem_pools_stat_free_pool */
/**
* Account allocation of chunk in a pool
* Account for freeing a chunk
*/
static void
mem_pools_stat_alloc_chunk (void)
mem_pools_stat_dealloc (void)
{
JERRY_ASSERT (mem_pools_stats.free_chunks > 0);
mem_pools_stats.allocated_chunks++;
mem_pools_stats.free_chunks--;
if (mem_pools_stats.allocated_chunks > mem_pools_stats.peak_allocated_chunks)
{
mem_pools_stats.peak_allocated_chunks = mem_pools_stats.allocated_chunks;
}
if (mem_pools_stats.allocated_chunks > mem_pools_stats.global_peak_allocated_chunks)
{
mem_pools_stats.global_peak_allocated_chunks = mem_pools_stats.allocated_chunks;
}
} /* mem_pools_stat_alloc_chunk */
/**
* Account freeing of chunk in a pool
*/
static void
mem_pools_stat_free_chunk (void)
{
JERRY_ASSERT (mem_pools_stats.allocated_chunks > 0);
mem_pools_stats.allocated_chunks--;
mem_pools_stats.free_chunks++;
} /* mem_pools_stat_free_chunk */
} /* mem_pools_stat_dealloc */
#endif /* MEM_STATS */
/**

20
jerry-core/mem/mem-poolman.h
View File

@ -1,4 +1,5 @@
/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -31,8 +32,8 @@
extern void mem_pools_init (void);
extern void mem_pools_finalize (void);
extern uint8_t *mem_pools_alloc (void);
extern void mem_pools_free (uint8_t *);
extern void *mem_pools_alloc (void);
extern void mem_pools_free (void *);
extern void mem_pools_collect_empty (void);
#ifdef MEM_STATS
@ -50,17 +51,14 @@ typedef struct
/** non-resettable peak pools' count */
size_t global_peak_pools_count;
/** allocated chunks count */
size_t allocated_chunks;
/** peak allocated chunks count */
size_t peak_allocated_chunks;
/** non-resettable peak allocated chunks count */
size_t global_peak_allocated_chunks;
/** free chunks count */
size_t free_chunks;
/* Number of newly allocated pool chunks */
size_t new_alloc_count;
/* Number of reused pool chunks */
size_t reused_count;
} mem_pools_stats_t;
extern void mem_pools_get_stats (mem_pools_stats_t *);

8
jerry-core/parser/js/common.h
View File

@ -52,11 +52,11 @@
/* Malloc functions. */
#define PARSER_MALLOC(size) mem_heap_alloc_block (size, MEM_HEAP_ALLOC_LONG_TERM)
#define PARSER_FREE(ptr) mem_heap_free_block ((void *) ptr)
#define PARSER_MALLOC(size) mem_heap_alloc_block_store_size (size)
#define PARSER_FREE(ptr) mem_heap_free_block_size_stored ((void *) ptr)
#define PARSER_MALLOC_LOCAL(size) mem_heap_alloc_block (size, MEM_HEAP_ALLOC_SHORT_TERM)
#define PARSER_FREE_LOCAL(ptr) mem_heap_free_block (ptr)
#define PARSER_MALLOC_LOCAL(size) mem_heap_alloc_block_store_size (size)
#define PARSER_FREE_LOCAL(ptr) mem_heap_free_block_size_stored (ptr)
/* UTF character management. Only ASCII characters are
* supported for simplicity. */

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

@ -1566,13 +1566,13 @@ lexer_construct_number_object (parser_context_t *context_p, /**< context */
num = -num;
}
lit_cp = rcs_cpointer_compress (lit_find_or_create_literal_from_num (num));
lit_cp = lit_cpointer_compress (lit_find_or_create_literal_from_num (num));
parser_list_iterator_init (&context_p->literal_pool, &literal_iterator);
while ((literal_p = (lexer_literal_t *) parser_list_iterator_next (&literal_iterator)) != NULL)
{
if (literal_p->type == LEXER_NUMBER_LITERAL
&& literal_p->u.value.u.value.base_cp == lit_cp.u.value.base_cp)
&& literal_p->u.value == lit_cp)
{
context_p->lit_object.literal_p = literal_p;
context_p->lit_object.index = (uint16_t) literal_index;

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

@ -18,6 +18,7 @@
#include "jerry-snapshot.h"
#include "js-parser-internal.h"
#include "lit-literal.h"
#include "lit-cpointer.h"
#ifdef PARSER_DUMP_BYTE_CODE
static int parser_show_instrs = PARSER_FALSE;
@ -100,7 +101,7 @@ parser_compute_indicies (parser_context_t *context_p, /**< context */
{
lit_literal_t lit = lit_find_or_create_literal_from_utf8_string (char_p,
literal_p->prop.length);
literal_p->u.value = rcs_cpointer_compress (lit);
literal_p->u.value = lit_cpointer_compress (lit);
if (!(literal_p->status_flags & LEXER_FLAG_SOURCE_PTR))
{
@ -521,7 +522,7 @@ parser_generate_initializers (parser_context_t *context_p, /**< context */
#ifdef PARSER_DUMP_BYTE_CODE
lit_literal_t lit = lit_find_or_create_literal_from_utf8_string (literal_p->u.char_p,
literal_p->prop.length);
literal_pool_p[literal_p->prop.index] = rcs_cpointer_compress (lit);
literal_pool_p[literal_p->prop.index] = lit_cpointer_compress (lit);
if (!context_p->is_show_opcodes
&& !(literal_p->status_flags & LEXER_FLAG_SOURCE_PTR))
@ -535,7 +536,7 @@ parser_generate_initializers (parser_context_t *context_p, /**< context */
else if ((literal_p->type == LEXER_FUNCTION_LITERAL)
|| (literal_p->type == LEXER_REGEXP_LITERAL))
{
ECMA_SET_NON_NULL_POINTER (literal_pool_p[literal_p->prop.index].u.value.base_cp,
ECMA_SET_NON_NULL_POINTER (literal_pool_p[literal_p->prop.index],
literal_p->u.bytecode_p);
}
else
@ -579,7 +580,7 @@ parser_generate_initializers (parser_context_t *context_p, /**< context */
JERRY_ASSERT (literal_p != NULL
&& literal_p->type == LEXER_FUNCTION_LITERAL);
init_index = literal_p->prop.index;
ECMA_SET_NON_NULL_POINTER (literal_pool_p[literal_p->prop.index].u.value.base_cp,
ECMA_SET_NON_NULL_POINTER (literal_pool_p[literal_p->prop.index],
literal_p->u.bytecode_p);
}
@ -1723,7 +1724,7 @@ parser_post_processing (parser_context_t *context_p) /**< context */
const uint8_t *char_p = context_p->source_end_p - (source_data & 0xfffff);
lit_literal_t lit = lit_find_or_create_literal_from_utf8_string (char_p,
source_data >> 20);
literal_pool_p[literal_p->prop.index] = rcs_cpointer_compress (lit);
literal_pool_p[literal_p->prop.index] = lit_cpointer_compress (lit);
}
}
}
@ -1753,7 +1754,7 @@ parser_post_processing (parser_context_t *context_p) /**< context */
{
if (literal_p->u.char_p == NULL)
{
literal_pool_p[argument_count] = rcs_cpointer_null_cp ();
literal_pool_p[argument_count] = lit_cpointer_null_cp ();
argument_count++;
continue;
}
@ -1775,7 +1776,7 @@ parser_post_processing (parser_context_t *context_p) /**< context */
if (context_p->status_flags & PARSER_NAMED_FUNCTION_EXP)
{
ECMA_SET_NON_NULL_POINTER (literal_pool_p[const_literal_end].u.value.base_cp,
ECMA_SET_NON_NULL_POINTER (literal_pool_p[const_literal_end],
compiled_code_p);
}

14
jerry-core/parser/regexp/re-compiler.c
View File

@ -72,12 +72,12 @@ re_realloc_regexp_bytecode_block (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytec
JERRY_ASSERT (bc_ctx_p->current_p >= bc_ctx_p->block_start_p);
size_t current_ptr_offset = (size_t) (bc_ctx_p->current_p - bc_ctx_p->block_start_p);
uint8_t *new_block_start_p = (uint8_t *) mem_heap_alloc_block (new_block_size,
MEM_HEAP_ALLOC_SHORT_TERM);
uint8_t *new_block_start_p = (uint8_t *) mem_heap_alloc_block_store_size (new_block_size);
if (bc_ctx_p->current_p)
{
memcpy (new_block_start_p, bc_ctx_p->block_start_p, (size_t) (current_ptr_offset));
mem_heap_free_block (bc_ctx_p->block_start_p);
mem_heap_free_block_size_stored (bc_ctx_p->block_start_p);
}
bc_ctx_p->block_start_p = new_block_start_p;
bc_ctx_p->block_end_p = new_block_start_p + new_block_size;
@ -128,11 +128,11 @@ re_bytecode_list_insert (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode conte
{
uint8_t *dest_p = src_p + length;
uint8_t *tmp_block_start_p;
tmp_block_start_p = (uint8_t *) mem_heap_alloc_block ((re_get_bytecode_length (bc_ctx_p) - offset),
MEM_HEAP_ALLOC_SHORT_TERM);
tmp_block_start_p = (uint8_t *) mem_heap_alloc_block_store_size (re_get_bytecode_length (bc_ctx_p) - offset);
memcpy (tmp_block_start_p, src_p, (size_t) (re_get_bytecode_length (bc_ctx_p) - offset));
memcpy (dest_p, tmp_block_start_p, (size_t) (re_get_bytecode_length (bc_ctx_p) - offset));
mem_heap_free_block (tmp_block_start_p);
mem_heap_free_block_size_stored (tmp_block_start_p);
}
memcpy (src_p, bytecode_p, length);
@ -698,7 +698,7 @@ re_compile_bytecode (re_compiled_code_t **out_bytecode_p, /**< out:pointer to by
if (!ecma_is_value_empty (ret_value))
{
/* Compilation failed, free bytecode. */
mem_heap_free_block (bc_ctx.block_start_p);
mem_heap_free_block_size_stored (bc_ctx.block_start_p);
*out_bytecode_p = NULL;
}
else

395
jerry-core/rcs/rcs-allocator.c
View File

@ -1,395 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rcs-allocator.h"
#include "rcs-records.h"
/**
* Assert that recordset state is correct.
*/
static void
rcs_assert_state_is_correct (rcs_record_set_t *rec_set_p __attr_unused___) /**< recordset */
{
#ifndef JERRY_DISABLE_HEAVY_DEBUG
size_t node_size_sum = 0;
size_t record_size_sum = 0;
rcs_record_t *last_record_p = NULL;
rcs_record_t *rec_p;
rcs_record_t *next_rec_p;
for (rec_p = rcs_record_get_first (rec_set_p);
rec_p != NULL;
last_record_p = rec_p, rec_p = next_rec_p)
{
JERRY_ASSERT (rcs_record_get_size (rec_p) > 0);
record_size_sum += rcs_record_get_size (rec_p);
rcs_chunked_list_node_t *node_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, rec_p);
next_rec_p = rcs_record_get_next (rec_set_p, rec_p);
rcs_chunked_list_node_t *next_node_p = NULL;
if (next_rec_p != NULL)
{
next_node_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, next_rec_p);
}
while (node_p != next_node_p)
{
node_p = rcs_chunked_list_get_next (node_p);
node_size_sum += rcs_get_node_data_space_size ();
}
}
JERRY_ASSERT (node_size_sum == record_size_sum);
record_size_sum = 0;
for (rec_p = last_record_p;
rec_p != NULL;
rec_p = rcs_record_get_prev (rec_set_p, rec_p))
{
record_size_sum += rcs_record_get_size (rec_p);
}
JERRY_ASSERT (node_size_sum == record_size_sum);
#endif /* !JERRY_DISABLE_HEAVY_DEBUG */
} /* rcs_assert_state_is_correct */
/**
* Initialize specified record as free record.
*/
static void
rcs_init_free_record (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *rec_p, /**< record to init as free record */
rcs_record_t *prev_rec_p, /**< previous record (or NULL) */
size_t size) /**< size, including header */
{
rcs_record_set_type (rec_p, RCS_RECORD_TYPE_FREE);
rcs_record_set_prev (rec_set_p, rec_p, prev_rec_p);
rcs_record_set_size (rec_p, size);
} /* rcs_init_free_record */
/**
* Check the alignment of the record.
*/
void
rcs_check_record_alignment (rcs_record_t *rec_p) /**< record */
{
JERRY_ASSERT (rec_p != NULL);
uintptr_t ptr = (uintptr_t) rec_p;
JERRY_ASSERT (JERRY_ALIGNUP (ptr, RCS_DYN_STORAGE_LENGTH_UNIT) == ptr);
} /* rcs_check_record_alignment */
/**
* Get size of a node's data space.
*
* @return size
*/
size_t
rcs_get_node_data_space_size (void)
{
return JERRY_ALIGNDOWN (rcs_chunked_list_get_node_data_space_size (), RCS_DYN_STORAGE_LENGTH_UNIT);
} /* rcs_get_node_data_space_size */
/**
* Get the node's data space.
*
* @return pointer to beginning of the node's data space
*/
uint8_t *
rcs_get_node_data_space (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_chunked_list_node_t *node_p) /**< the node */
{
uintptr_t unaligned_data_space_start = (uintptr_t) rcs_chunked_list_get_node_data_space (rec_set_p, node_p);
uintptr_t aligned_data_space_start = JERRY_ALIGNUP (unaligned_data_space_start, RCS_DYN_STORAGE_LENGTH_UNIT);
JERRY_ASSERT (unaligned_data_space_start + rcs_chunked_list_get_node_data_space_size ()
== aligned_data_space_start + rcs_chunked_list_get_node_data_space_size ());
return (uint8_t *) aligned_data_space_start;
} /* rcs_get_node_data_space */
/**
* Initialize record in specified place, and, if there is free space
* before next record, initialize free record for the space.
*/
static void
rcs_alloc_record_in_place (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *place_p, /**< where to initialize the record */
rcs_record_t *next_record_p, /**< next allocated record */
size_t free_size) /**< size of free part between the allocated record
and the next allocated record */
{
const size_t node_data_space_size = rcs_get_node_data_space_size ();
if (next_record_p != NULL)
{
if (free_size == 0)
{
rcs_record_set_prev (rec_set_p, next_record_p, place_p);
}
else
{
rcs_chunked_list_node_t *node_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, next_record_p);
uint8_t *node_data_space_p = rcs_get_node_data_space (rec_set_p, node_p);
JERRY_ASSERT ((uint8_t *) next_record_p < node_data_space_p + node_data_space_size);
rcs_record_t *free_rec_p;
if ((uint8_t *) next_record_p >= node_data_space_p + free_size)
{
free_rec_p = (rcs_record_t *) ((uint8_t *) next_record_p - free_size);
}
else
{
size_t size_passed_back = (size_t) ((uint8_t *) next_record_p - node_data_space_p);
JERRY_ASSERT (size_passed_back < free_size && size_passed_back + node_data_space_size > free_size);
node_p = rcs_chunked_list_get_prev (node_p);
node_data_space_p = rcs_get_node_data_space (rec_set_p, node_p);
free_rec_p = (rcs_record_t *) (node_data_space_p + node_data_space_size - \
(free_size - size_passed_back));
}
rcs_init_free_record (rec_set_p, free_rec_p, place_p, free_size);
}
}
else if (free_size != 0)
{
rcs_chunked_list_node_t *node_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, place_p);
JERRY_ASSERT (node_p != NULL);
rcs_chunked_list_node_t *next_node_p = rcs_chunked_list_get_next (node_p);
while (next_node_p != NULL)
{
node_p = next_node_p;
next_node_p = rcs_chunked_list_get_next (node_p);
}
uint8_t *node_data_space_p = rcs_get_node_data_space (rec_set_p, node_p);
const size_t node_data_space_size = rcs_get_node_data_space_size ();
rcs_record_t *free_rec_p = (rcs_record_t *) (node_data_space_p + node_data_space_size - free_size);
rcs_init_free_record (rec_set_p, free_rec_p, place_p, free_size);
}
} /* rcs_alloc_record_in_place */
/**
* Allocate record of specified size.
*
* @return record identifier
*/
static rcs_record_t *
rcs_alloc_space_for_record (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t **out_prev_rec_p, /**< out: pointer to record, previous to the allocated,
* or NULL if the allocated record is the first */
size_t bytes) /**< size */
{
rcs_assert_state_is_correct (rec_set_p);
JERRY_ASSERT (JERRY_ALIGNUP (bytes, RCS_DYN_STORAGE_LENGTH_UNIT) == bytes);
JERRY_ASSERT (out_prev_rec_p != NULL);
rcs_record_t *rec_p = NULL;
*out_prev_rec_p = NULL;
const size_t node_data_space_size = rcs_get_node_data_space_size ();
for (rec_p = rcs_record_get_first (rec_set_p);
rec_p != NULL;
*out_prev_rec_p = rec_p, rec_p = rcs_record_get_next (rec_set_p, rec_p))
{
if (RCS_RECORD_IS_FREE (rec_p))
{
rcs_record_t *next_rec_p = rcs_record_get_next (rec_set_p, rec_p);
size_t record_size = rcs_record_get_size (rec_p);
if (record_size >= bytes)
{
/* Record size is sufficient. */
rcs_alloc_record_in_place (rec_set_p, rec_p, next_rec_p, record_size - bytes);
return rec_p;
}
rcs_chunked_list_node_t *node_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, rec_p);
uint8_t *node_data_space_p = rcs_get_node_data_space (rec_set_p, node_p);
uint8_t *node_data_space_end_p = node_data_space_p + node_data_space_size;
uint8_t *rec_space_p = (uint8_t *) rec_p;
if (rec_space_p + record_size >= node_data_space_end_p)
{
/* Record lies up to end of node's data space size,
* thus it can be extended up to necessary size. */
while (record_size < bytes)
{
node_p = rcs_chunked_list_insert_new (rec_set_p, node_p);
record_size += node_data_space_size;
}
rcs_alloc_record_in_place (rec_set_p, rec_p, next_rec_p, record_size - bytes);
return rec_p;
}
if (next_rec_p == NULL)
{
/* There are no more records in the storage,
* so we should append a new record. */
break;
}
JERRY_ASSERT (!RCS_RECORD_IS_FREE (rec_p));
}
}
/* Free record of sufficient size was not found. */
rcs_chunked_list_node_t *node_p = rcs_chunked_list_append_new (rec_set_p);
rcs_record_t *new_rec_p = (rcs_record_t *) rcs_get_node_data_space (rec_set_p, node_p);
size_t allocated_size = node_data_space_size;
while (allocated_size < bytes)
{
allocated_size += node_data_space_size;
rcs_chunked_list_append_new (rec_set_p);
}
rcs_alloc_record_in_place (rec_set_p, new_rec_p, NULL, allocated_size - bytes);
return new_rec_p;
} /* rcs_alloc_space_for_record */
/**
* Allocate and initialize a new record.
*
* @return pointer to the new record
*/
rcs_record_t *
rcs_alloc_record (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_type_t type, /**< type for the new record */
size_t size) /**< allocation size */
{
JERRY_ASSERT (type >= RCS_RECORD_TYPE_FIRST && type <= RCS_RECORD_TYPE_LAST);
rcs_record_t *prev_rec_p;
rcs_record_t *rec_p = (rcs_record_t *) rcs_alloc_space_for_record (rec_set_p, &prev_rec_p, size);
rcs_record_set_type (rec_p, type);
rcs_record_set_size (rec_p, size);
rcs_record_set_prev (rec_set_p, rec_p, prev_rec_p);
rcs_assert_state_is_correct (rec_set_p);
return rec_p;
} /* rcs_alloc_record */
/**
* Free the specified record.
*/
void
rcs_free_record (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *record_p) /**< record to free */
{
JERRY_ASSERT (record_p != NULL);
rcs_assert_state_is_correct (rec_set_p);
rcs_record_t *prev_rec_p = rcs_record_get_prev (rec_set_p, record_p);
rcs_init_free_record (rec_set_p, record_p, prev_rec_p, rcs_record_get_size (record_p));
/* Merge adjacent free records, if there are any,
* and free nodes of chunked list that became unused. */
rcs_record_t *rec_from_p = record_p;
rcs_record_t *rec_to_p = rcs_record_get_next (rec_set_p, record_p);
if (prev_rec_p != NULL && RCS_RECORD_IS_FREE (prev_rec_p))
{
rec_from_p = prev_rec_p;
prev_rec_p = rcs_record_get_prev (rec_set_p, rec_from_p);
}
if (rec_to_p != NULL && RCS_RECORD_IS_FREE (rec_to_p))
{
rec_to_p = rcs_record_get_next (rec_set_p, rec_to_p);
}
JERRY_ASSERT (rec_from_p != NULL && RCS_RECORD_IS_FREE (rec_from_p));
JERRY_ASSERT (rec_to_p == NULL || !RCS_RECORD_IS_FREE (rec_to_p));
rcs_chunked_list_node_t *node_from_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, rec_from_p);
rcs_chunked_list_node_t *node_to_p = NULL;
if (rec_to_p != NULL)
{
node_to_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, rec_to_p);
}
const size_t node_data_space_size = rcs_get_node_data_space_size ();
uint8_t *rec_from_beg_p = (uint8_t *) rec_from_p;
uint8_t *rec_to_beg_p = (uint8_t *) rec_to_p;
size_t free_size;
if (node_from_p == node_to_p)
{
JERRY_ASSERT (rec_from_beg_p + rcs_record_get_size (rec_from_p) <= rec_to_beg_p);
free_size = (size_t) (rec_to_beg_p - rec_from_beg_p);
}
else
{
rcs_chunked_list_node_t *iter_node_p;
rcs_chunked_list_node_t *iter_next_node_p;
for (iter_node_p = rcs_chunked_list_get_next (node_from_p);
iter_node_p != node_to_p;
iter_node_p = iter_next_node_p)
{
iter_next_node_p = rcs_chunked_list_get_next (iter_node_p);
rcs_chunked_list_remove (rec_set_p, iter_node_p);
}
JERRY_ASSERT (rcs_chunked_list_get_next (node_from_p) == node_to_p);
size_t node_from_space = (size_t) (rcs_get_node_data_space (rec_set_p, node_from_p) \
+ node_data_space_size - rec_from_beg_p);
size_t node_to_space = (size_t) (node_to_p != NULL ? \
(rec_to_beg_p - rcs_get_node_data_space (rec_set_p, node_to_p)) : 0);
free_size = node_from_space + node_to_space;
}
rcs_init_free_record (rec_set_p, rec_from_p, prev_rec_p, free_size);
if (rec_to_p != NULL)
{
rcs_record_set_prev (rec_set_p, rec_to_p, rec_from_p);
}
else if (prev_rec_p == NULL)
{
rcs_chunked_list_remove (rec_set_p, node_from_p);
JERRY_ASSERT (node_to_p == NULL);
JERRY_ASSERT (rcs_chunked_list_get_first (rec_set_p) == NULL);
}
rcs_assert_state_is_correct (rec_set_p);
} /* rcs_free_record */

28
jerry-core/rcs/rcs-allocator.h
View File

@ -1,28 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RCS_ALLOCATOR_H
#define RCS_ALLOCATOR_H
#include "rcs-globals.h"
extern void rcs_check_record_alignment (rcs_record_t *);
extern void rcs_free_record (rcs_record_set_t *, rcs_record_t *);
extern size_t rcs_get_node_data_space_size (void);
extern uint8_t *rcs_get_node_data_space (rcs_record_set_t *, rcs_chunked_list_node_t *);
extern rcs_record_t *rcs_alloc_record (rcs_record_set_t *, rcs_record_type_t, size_t);
#endif /* !RCS_ALLOCATOR_H */

340
jerry-core/rcs/rcs-chunked-list.c
View File

@ -1,340 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rcs-chunked-list.h"
/**
* Set previous node for the specified node
*/
static void
rcs_chunked_list_set_prev (rcs_chunked_list_node_t *node_p, /**< node to set previous for */
rcs_chunked_list_node_t *prev_node_p) /**< the previous node */
{
JERRY_ASSERT (node_p != NULL);
MEM_CP_SET_POINTER (node_p->prev_cp, prev_node_p);
} /* rcs_chunked_list_set_prev */
/**
* Set next node for the specified node
*/
static void
rcs_chunked_list_set_next (rcs_chunked_list_node_t *node_p, /**< node to set next for */
rcs_chunked_list_node_t *next_node_p) /**< the next node */
{
JERRY_ASSERT (node_p != NULL);
MEM_CP_SET_POINTER (node_p->next_cp, next_node_p);
} /* rcs_chunked_list_set_next */
/**
* Get size of the node
*
* @return size of node, including header and data space
*/
static size_t
rcs_chunked_list_get_node_size (void)
{
size_t size = mem_heap_recommend_allocation_size (sizeof (rcs_chunked_list_node_t) + 1u);
JERRY_ASSERT (size != 0 && size >= sizeof (rcs_chunked_list_node_t));
return size;
} /* rcs_chunked_list_get_node_size */
/**
* Assert that the list state is correct
*/
static void
rcs_assert_chunked_list_is_correct (rcs_chunked_list_t *cl_p) /**< the chunked_list */
{
#ifndef JERRY_DISABLE_HEAVY_DEBUG
for (rcs_chunked_list_node_t *node_iter_p = rcs_chunked_list_get_first (cl_p);
node_iter_p != NULL;
node_iter_p = rcs_chunked_list_get_next (node_iter_p))
{
rcs_chunked_list_node_t *prev_node_p = rcs_chunked_list_get_prev (node_iter_p);
rcs_chunked_list_node_t *next_node_p = rcs_chunked_list_get_next (node_iter_p);
JERRY_ASSERT ((node_iter_p == cl_p->head_p
&& prev_node_p == NULL)
|| (node_iter_p != cl_p->head_p
&& prev_node_p != NULL
&& rcs_chunked_list_get_next (prev_node_p) == node_iter_p));
JERRY_ASSERT ((node_iter_p == cl_p->tail_p
&& next_node_p == NULL)
|| (node_iter_p != cl_p->tail_p
&& next_node_p != NULL
&& rcs_chunked_list_get_prev (next_node_p) == node_iter_p));
}
#else
(void) cl_p;
#endif /* !JERRY_DISABLE_HEAVY_DEBUG */
} /* rcs_assert_chunked_list_is_correct */
/**
* Assert that state of specified node is correct
*/
static void
rcs_assert_chunked_list_node_is_correct (rcs_chunked_list_t *cl_p, /**< the chunked_list */
rcs_chunked_list_node_t *node_p) /**< the node */
{
#ifndef JERRY_DISABLE_HEAVY_DEBUG
JERRY_ASSERT (node_p != NULL);
rcs_assert_chunked_list_is_correct (cl_p);
bool is_in_list = false;
for (rcs_chunked_list_node_t *node_iter_p = rcs_chunked_list_get_first (cl_p);
node_iter_p != NULL;
node_iter_p = rcs_chunked_list_get_next (node_iter_p))
{
if (node_iter_p == node_p)
{
is_in_list = true;
break;
}
}
JERRY_ASSERT (is_in_list);
#else /* !JERRY_DISABLE_HEAVY_DEBUG */
(void) node_p;
(void) cl_p;
#endif /* JERRY_DISABLE_HEAVY_DEBUG */
} /* rcs_assert_chunked_list_node_is_correct */
/**
* Initializarion
*/
void
rcs_chunked_list_init (rcs_chunked_list_t *cl_p) /**< the chunked_list */
{
cl_p->head_p = NULL;
cl_p->tail_p = NULL;
} /* rcs_chunked_list_init */
/**
* Free
*/
void
rcs_chunked_list_free (rcs_chunked_list_t *cl_p) /**< the chunked_list */
{
JERRY_ASSERT (cl_p->head_p == NULL);
JERRY_ASSERT (cl_p->tail_p == NULL);
} /* rcs_chunked_list_free */
void
rcs_chunked_list_cleanup (rcs_chunked_list_t *cl_p) /**< the chunked_list */
{
while (cl_p->head_p)
{
rcs_chunked_list_remove (cl_p, cl_p->head_p);
}
} /* rcs_chunked_list_cleanup */
/**
* Get first node of the list
*
* @return pointer to the first node
*/
rcs_chunked_list_node_t *
rcs_chunked_list_get_first (rcs_chunked_list_t *cl_p) /**< the chunked_list */
{
return cl_p->head_p;
} /* rcs_chunked_list_get_first */
/**
* Get last node of the list
*
* @return pointer to the last node
*/
rcs_chunked_list_node_t *
rcs_chunked_list_get_last (rcs_chunked_list_t *cl_p) /**< the chunked_list */
{
return cl_p->tail_p;
} /* rcs_chunked_list_get_last */
/**
* Get node, previous to specified
*
* @return pointer to previous node
*/
rcs_chunked_list_node_t *
rcs_chunked_list_get_prev (rcs_chunked_list_node_t *node_p) /**< the node in the chunked_list */
{
JERRY_ASSERT (node_p != NULL);
return MEM_CP_GET_POINTER (rcs_chunked_list_node_t, node_p->prev_cp);
} /* rcs_chunked_list_get_prev */
/**
* Get node, next to specified
*
* @return pointer to next node
*/
rcs_chunked_list_node_t *
rcs_chunked_list_get_next (rcs_chunked_list_node_t *node_p) /**< the node in the chunked_list */
{
JERRY_ASSERT (node_p != NULL);
return MEM_CP_GET_POINTER (rcs_chunked_list_node_t, node_p->next_cp);
} /* rcs_chunked_list_get_next */
/**
* Append new node to end of the list
*
* @return pointer to the new node
*/
rcs_chunked_list_node_t *
rcs_chunked_list_append_new (rcs_chunked_list_t *cl_p) /**< the chunked_list */
{
rcs_assert_chunked_list_is_correct (cl_p);
rcs_chunked_list_node_t *node_p =
(rcs_chunked_list_node_t *) mem_heap_alloc_chunked_block (MEM_HEAP_ALLOC_LONG_TERM);
rcs_chunked_list_set_prev (node_p, cl_p->tail_p);
rcs_chunked_list_set_next (node_p, NULL);
if (cl_p->head_p == NULL)
{
JERRY_ASSERT (cl_p->tail_p == NULL);
cl_p->head_p = node_p;
cl_p->tail_p = node_p;
}
else
{
JERRY_ASSERT (cl_p->tail_p != NULL);
rcs_chunked_list_set_next (cl_p->tail_p, node_p);
cl_p->tail_p = node_p;
}
rcs_assert_chunked_list_node_is_correct (cl_p, node_p);
return node_p;
} /* rcs_chunked_list_append_new */
/**
* Insert new node after the specified node
*
* @return pointer to the new node
*/
rcs_chunked_list_node_t *
rcs_chunked_list_insert_new (rcs_chunked_list_t *cl_p, /**< the chunked_list */
rcs_chunked_list_node_t *after_p) /**< the node to insert the new node after */
{
rcs_assert_chunked_list_is_correct (cl_p);
rcs_chunked_list_node_t *node_p =
(rcs_chunked_list_node_t *) mem_heap_alloc_chunked_block (MEM_HEAP_ALLOC_LONG_TERM);
JERRY_ASSERT (cl_p->head_p != NULL);
JERRY_ASSERT (cl_p->tail_p != NULL);
rcs_assert_chunked_list_node_is_correct (cl_p, after_p);
rcs_chunked_list_set_next (after_p, node_p);
if (cl_p->tail_p == after_p)
{
cl_p->tail_p = node_p;
}
rcs_chunked_list_set_prev (node_p, after_p);
rcs_chunked_list_set_next (node_p, NULL);
rcs_assert_chunked_list_node_is_correct (cl_p, node_p);
return node_p;
} /* rcs_chunked_list_insert_new */
/**
* Remove specified node
*/
void
rcs_chunked_list_remove (rcs_chunked_list_t *cl_p, /**< the chunked_list */
rcs_chunked_list_node_t *node_p) /**< the node to remove */
{
JERRY_ASSERT (cl_p->head_p != NULL);
JERRY_ASSERT (cl_p->tail_p != NULL);
rcs_assert_chunked_list_node_is_correct (cl_p, node_p);
rcs_chunked_list_node_t *prev_node_p, *next_node_p;
prev_node_p = rcs_chunked_list_get_prev (node_p);
next_node_p = rcs_chunked_list_get_next (node_p);
if (prev_node_p == NULL)
{
JERRY_ASSERT (cl_p->head_p == node_p);
cl_p->head_p = next_node_p;
}
else
{
rcs_chunked_list_set_next (prev_node_p, next_node_p);
}
if (next_node_p == NULL)
{
JERRY_ASSERT (cl_p->tail_p == node_p);
cl_p->tail_p = prev_node_p;
}
else
{
rcs_chunked_list_set_prev (next_node_p, prev_node_p);
}
mem_heap_free_block (node_p);
rcs_assert_chunked_list_is_correct (cl_p);
} /* rcs_chunked_list_remove */
/**
* Find node containing space, pointed by specified pointer
*
* @return pointer to the node that contains the pointed area
*/
rcs_chunked_list_node_t *
rcs_chunked_list_get_node_from_pointer (rcs_chunked_list_t *cl_p, /**< the chunked_list */
void *ptr) /**< the pointer value */
{
rcs_chunked_list_node_t *node_p = (rcs_chunked_list_node_t *) mem_heap_get_chunked_block_start (ptr);
rcs_assert_chunked_list_node_is_correct (cl_p, node_p);
return node_p;
} /* rcs_chunked_list_get_node_from_pointer */
/**
* Get the node's data space
*
* @return pointer to beginning of the node's data space
*/
uint8_t *
rcs_chunked_list_get_node_data_space (rcs_chunked_list_t *cl_p, /**< the chunked_list */
rcs_chunked_list_node_t *node_p) /**< the node */
{
rcs_assert_chunked_list_node_is_correct (cl_p, node_p);
return (uint8_t *) (node_p + 1);
} /* rcs_chunked_list_get_node_data_space */
/**
* Get size of a node's data space
*
* @return size
*/
size_t
rcs_chunked_list_get_node_data_space_size (void)
{
return rcs_chunked_list_get_node_size () - sizeof (rcs_chunked_list_node_t);
} /* rcs_chunked_list_get_node_data_space_size */

68
jerry-core/rcs/rcs-chunked-list.h
View File

@ -1,68 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RCS_CHUNKED_LIST_H
#define RCS_CHUNKED_LIST_H
#include "mem-allocator.h"
/** \addtogroup recordset Recordset
* @{
*
* \addtogroup chunkedlist Chunked list
*
* List of nodes with size exactly fit to one memory heap's chunk.
*
* @{
*/
/**
* List node
*/
typedef struct
{
mem_cpointer_t prev_cp; /**< prev list's node */
mem_cpointer_t next_cp; /**< next list's node */
} rcs_chunked_list_node_t;
/**
* Chunked list
*/
typedef struct
{
rcs_chunked_list_node_t *head_p; /**< head node of list */
rcs_chunked_list_node_t *tail_p; /**< tail node of list */
} rcs_chunked_list_t;
extern void rcs_chunked_list_init (rcs_chunked_list_t *);
extern void rcs_chunked_list_free (rcs_chunked_list_t *);
extern void rcs_chunked_list_cleanup (rcs_chunked_list_t *);
extern rcs_chunked_list_node_t *rcs_chunked_list_get_first (rcs_chunked_list_t *);
extern rcs_chunked_list_node_t *rcs_chunked_list_get_last (rcs_chunked_list_t *);
extern rcs_chunked_list_node_t *rcs_chunked_list_get_prev (rcs_chunked_list_node_t *);
extern rcs_chunked_list_node_t *rcs_chunked_list_get_next (rcs_chunked_list_node_t *);
extern rcs_chunked_list_node_t *rcs_chunked_list_append_new (rcs_chunked_list_t *);
extern rcs_chunked_list_node_t *rcs_chunked_list_insert_new (rcs_chunked_list_t *, rcs_chunked_list_node_t *);
extern void rcs_chunked_list_remove (rcs_chunked_list_t *, rcs_chunked_list_node_t *);
extern rcs_chunked_list_node_t *rcs_chunked_list_get_node_from_pointer (rcs_chunked_list_t *, void *);
extern uint8_t *rcs_chunked_list_get_node_data_space (rcs_chunked_list_t *, rcs_chunked_list_node_t *);
extern size_t rcs_chunked_list_get_node_data_space_size (void);
/**
* @}
* @}
*/
#endif /* RCS_CHUNKED_LIST_H */

104
jerry-core/rcs/rcs-cpointer.c
View File

@ -1,104 +0,0 @@
/* Copyright 2015-2016 Samsung Electronics Co., Ltd.
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rcs-cpointer.h"
#include "jrt-bit-fields.h"
/**
* Compress pointer to extended compressed pointer.
*
* @return dynamic storage-specific extended compressed pointer
*/
rcs_cpointer_t
rcs_cpointer_compress (rcs_record_t *pointer) /**< pointer to compress */
{
rcs_cpointer_t cpointer;
cpointer.u.packed_value = 0;
uintptr_t base_pointer = JERRY_ALIGNDOWN ((uintptr_t) pointer, MEM_ALIGNMENT);
if ((void *) base_pointer == NULL)
{
cpointer.u.value.base_cp = MEM_CP_NULL;
}
else
{
cpointer.u.value.base_cp = mem_compress_pointer ((void *) base_pointer) & MEM_CP_MASK;
}
#if MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_LENGTH_UNIT_LOG
/*
* If alignment of a unit in recordset storage is less than required by MEM_ALIGNMENT_LOG,
* then mem_cpointer_t can't store pointer to the unit, and so, rcs_cpointer_t stores
* mem_cpointer_t to block, aligned to MEM_ALIGNMENT, and also extension with difference
* between positions of the MEM_ALIGNMENT-aligned block and the unit.
*/
uintptr_t diff = (uintptr_t) pointer - base_pointer;
JERRY_ASSERT (diff < MEM_ALIGNMENT);
JERRY_ASSERT (JRT_EXTRACT_BIT_FIELD (uintptr_t, diff, 0, RCS_DYN_STORAGE_LENGTH_UNIT_LOG) == 0);
uintptr_t ext_part = (uintptr_t) JRT_EXTRACT_BIT_FIELD (uintptr_t, diff,
RCS_DYN_STORAGE_LENGTH_UNIT_LOG,
MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_LENGTH_UNIT_LOG);
cpointer.u.value.ext = ext_part & ((1ull << (MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_LENGTH_UNIT_LOG)) - 1);
#endif /* MEM_ALIGNMENT > RCS_DYN_STORAGE_LENGTH_UNIT_LOG */
JERRY_ASSERT (rcs_cpointer_decompress (cpointer) == pointer);
return cpointer;
} /* rcs_cpointer_compress */
/**
* Decompress extended compressed pointer.
*
* @return decompressed pointer
*/
rcs_record_t *
rcs_cpointer_decompress (rcs_cpointer_t compressed_pointer) /**< recordset-specific compressed pointer */
{
uint8_t *base_pointer = NULL;
if (compressed_pointer.u.value.base_cp != MEM_CP_NULL)
{
base_pointer = (uint8_t *) mem_decompress_pointer (compressed_pointer.u.value.base_cp);
}
uintptr_t diff = 0;
#if MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_LENGTH_UNIT_LOG
/*
* See also:
* rcs_cpointer_compress
*/
diff = (uintptr_t) compressed_pointer.u.value.ext << RCS_DYN_STORAGE_LENGTH_UNIT_LOG;
#endif /* MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_LENGTH_UNIT_LOG */
rcs_record_t *rec_p = (rcs_record_t *) (base_pointer + diff);
return rec_p;
} /* rcs_cpointer_decompress */
/**
* Create NULL compressed pointer.
*
* @return NULL compressed pointer
*/
rcs_cpointer_t rcs_cpointer_null_cp (void)
{
rcs_cpointer_t cp;
cp.u.packed_value = MEM_CP_NULL;
return cp;
} /* rcs_cpointer_null_cp */

53
jerry-core/rcs/rcs-cpointer.h
View File

@ -1,53 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RCS_CPOINTER_H
#define RCS_CPOINTER_H
#include "rcs-globals.h"
#define RCS_CPOINTER_WIDTH (MEM_CP_WIDTH + MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_LENGTH_UNIT_LOG)
/**
* Dynamic storage-specific extended compressed pointer
*
* Note:
* the pointer can represent addresses aligned by RCS_DYN_STORAGE_LENGTH_UNIT,
* while mem_cpointer_t can only represent addresses aligned by MEM_ALIGNMENT.
*/
typedef struct
{
union
{
struct
{
__extension__ mem_cpointer_t base_cp : MEM_CP_WIDTH; /**< pointer to base of addressed area */
#if MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_LENGTH_UNIT_LOG
__extension__ uint16_t ext : (MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_LENGTH_UNIT_LOG); /**< extension of the basic
* compressed pointer
* used for more detailed
* addressing */
#endif /* MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_LENGTH_UNIT_LOG */
} value;
uint16_t packed_value;
} u;
} rcs_cpointer_t;
extern rcs_cpointer_t rcs_cpointer_compress (rcs_record_t *);
extern rcs_record_t *rcs_cpointer_decompress (rcs_cpointer_t);
extern rcs_cpointer_t rcs_cpointer_null_cp ();
#endif /* !RCS_CPOINTER_H */

54
jerry-core/rcs/rcs-globals.h
View File

@ -1,54 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RCS_GLOBALS_H
#define RCS_GLOBALS_H
#include "rcs-chunked-list.h"
/**
* Represents the type of the record.
*/
typedef enum
{
RCS_RECORD_TYPE_FREE = 0, /**< Free record that marks an empty space. It doesn't hold any values. */
RCS_RECORD_TYPE_CHARSET = 1, /**< Charset record that holds characters. */
RCS_RECORD_TYPE_MAGIC_STR = 2, /**< Magic string record that holds a magic string id. */
RCS_RECORD_TYPE_MAGIC_STR_EX = 3, /**< External magic string record that holds an extrernal magic string id. */
RCS_RECORD_TYPE_NUMBER = 4 /**< Number record that holds a numeric value. */
} rcs_record_type_t;
/**
* Record type
*/
typedef uint8_t rcs_record_t;
/**
* Recordset type
*/
typedef rcs_chunked_list_t rcs_record_set_t;
/**
* Logarithm of a dynamic storage unit alignment
*/
#define RCS_DYN_STORAGE_LENGTH_UNIT_LOG (2u)
/**
* Unit of length
*/
#define RCS_DYN_STORAGE_LENGTH_UNIT ((size_t) (1ull << RCS_DYN_STORAGE_LENGTH_UNIT_LOG))
#endif /* !RCS_GLOBALS_H */

215
jerry-core/rcs/rcs-iterator.c
View File

@ -1,215 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rcs-iterator.h"
#include "rcs-allocator.h"
#include "rcs-records.h"
/**
* Represents the memory access on the literal storage.
*/
typedef enum
{
RCS_ITERATOR_ACCESS_WRITE = 0, /**< Write 'size' bytes from 'data' buffer to the record. */
RCS_ITERATOR_ACCESS_READ = 1, /**< Read 'size' bytes from the record and write to the 'data' buffer. */
RCS_ITERATOR_ACCESS_SKIP = 2 /**< Increment current position so that 'size' bytes would be skipped. */
} rcs_access_t;
/**
* Create an iterator context.
*
* @return an initialized iterator context
*/
rcs_iterator_t
rcs_iterator_create (rcs_record_set_t *recordset_p, /**< recordset */
rcs_record_t *record_p) /**< start record */
{
rcs_iterator_t ctx;
{
ctx.recordset_p = recordset_p;
ctx.record_start_p = record_p;
rcs_iterator_reset (&ctx);
}
return ctx;
} /* rcs_iterator_create */
/**
* Perform general access to the record
*
* Warning: This function is implemented in assumption that `size` is not more than `2 * node_data_space_size`.
*/
static void
rcs_iterator_access (rcs_iterator_t *ctx_p, /**< iterator context */
void *data, /**< iterator context */
size_t size, /**< iterator context */
rcs_access_t access_type) /**< access type */
{
const size_t node_data_space_size = rcs_get_node_data_space_size ();
JERRY_ASSERT (2 * node_data_space_size >= size);
const size_t record_size = rcs_record_get_size (ctx_p->record_start_p);
JERRY_ASSERT (!rcs_iterator_finished (ctx_p));
rcs_chunked_list_node_t *current_node_p =
rcs_chunked_list_get_node_from_pointer (ctx_p->recordset_p, ctx_p->current_pos_p);
uint8_t *current_node_data_space_p = rcs_get_node_data_space (ctx_p->recordset_p, current_node_p);
size_t left_in_node = node_data_space_size - (size_t) (ctx_p->current_pos_p - current_node_data_space_p);
JERRY_ASSERT (ctx_p->current_offset + size <= record_size);
/*
* Read the data and increase the current position pointer.
*/
if (left_in_node >= size)
{
/* all data is placed inside single node */
if (access_type == RCS_ITERATOR_ACCESS_READ)
{
memcpy (data, ctx_p->current_pos_p, size);
}
else if (access_type == RCS_ITERATOR_ACCESS_WRITE)
{
memcpy (ctx_p->current_pos_p, data, size);
}
else
{
JERRY_ASSERT (access_type == RCS_ITERATOR_ACCESS_SKIP);
if (left_in_node > size)
{
ctx_p->current_pos_p += size;
}
else if (ctx_p->current_offset + size < record_size)
{
current_node_p = rcs_chunked_list_get_next (current_node_p);
JERRY_ASSERT (current_node_p);
ctx_p->current_pos_p = rcs_get_node_data_space (ctx_p->recordset_p, current_node_p);
}
else
{
JERRY_ASSERT (ctx_p->current_offset + size == record_size);
}
}
}
else
{
/* Data is distributed between two nodes. */
const size_t first_chunk_size = node_data_space_size - (size_t) (ctx_p->current_pos_p - current_node_data_space_p);
if (access_type == RCS_ITERATOR_ACCESS_READ)
{
memcpy (data, ctx_p->current_pos_p, first_chunk_size);
}
else if (access_type == RCS_ITERATOR_ACCESS_WRITE)
{
memcpy (ctx_p->current_pos_p, data, first_chunk_size);
}
rcs_chunked_list_node_t *next_node_p = rcs_chunked_list_get_next (current_node_p);
JERRY_ASSERT (next_node_p != NULL);
uint8_t *next_node_data_space_p = rcs_get_node_data_space (ctx_p->recordset_p, next_node_p);
if (access_type == RCS_ITERATOR_ACCESS_READ)
{
memcpy ((uint8_t *) data + first_chunk_size, next_node_data_space_p, size - first_chunk_size);
}
else if (access_type == RCS_ITERATOR_ACCESS_WRITE)
{
memcpy (next_node_data_space_p, (uint8_t *) data + first_chunk_size, size - first_chunk_size);
}
else
{
JERRY_ASSERT (access_type == RCS_ITERATOR_ACCESS_SKIP);
ctx_p->current_pos_p = next_node_data_space_p + size - first_chunk_size;
}
}
/* Check if we reached the end. */
if (access_type == RCS_ITERATOR_ACCESS_SKIP)
{
ctx_p->current_offset += size;
JERRY_ASSERT (ctx_p->current_offset <= record_size);
if (ctx_p->current_offset == record_size)
{
ctx_p->current_pos_p = NULL;
ctx_p->current_offset = 0;
}
}
} /* rcs_iterator_access */
/**
* Read a value from the record.
* After reading iterator doesn't change its position.
*
* @return read value
*/
void
rcs_iterator_read (rcs_iterator_t *ctx_p, /**< iterator context */
void *out_data, /**< value to read */
size_t size) /**< size to read */
{
rcs_iterator_access (ctx_p, out_data, size, RCS_ITERATOR_ACCESS_READ);
} /* rcs_iterator_read */
/**
* Write a value to the record.
* After writing, iterator doesn't change its position.
*/
void
rcs_iterator_write (rcs_iterator_t *ctx_p, /**< iterator context */
void *value, /**< value to write */
size_t size) /**< size to write */
{
rcs_iterator_access (ctx_p, value, size, RCS_ITERATOR_ACCESS_WRITE);
} /* rcs_iterator_write */
/**
* Increment current position to skip 'size' bytes.
*/
void
rcs_iterator_skip (rcs_iterator_t *ctx_p, /**< iterator context */
size_t size) /**< size to skip */
{
if (size)
{
rcs_iterator_access (ctx_p, NULL, size, RCS_ITERATOR_ACCESS_SKIP);
}
} /* rcs_iterator_skip */
/**
* Reset the iterator, so that it points to the beginning of the record.
*/
void
rcs_iterator_reset (rcs_iterator_t *ctx_p) /**< iterator context */
{
ctx_p->current_pos_p = ctx_p->record_start_p;
ctx_p->current_offset = 0;
} /* rcs_iterator_reset */
/**
* Check if the end of the record was reached.
*
* @return true if the whole record was iterated
* false otherwise
*/
bool
rcs_iterator_finished (rcs_iterator_t *ctx_p) /**< iterator context */
{
return ctx_p->current_pos_p == NULL;
} /* rcs_iterator_finished */

42
jerry-core/rcs/rcs-iterator.h
View File

@ -1,42 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RCS_ITERATOR_H
#define RCS_ITERATOR_H
#include "ecma-globals.h"
/**
* Represents a context for the iterator.
*/
typedef struct
{
rcs_record_set_t *recordset_p; /**< recordset, containing the records */
rcs_record_t *record_start_p; /**< start of current record */
uint8_t *current_pos_p; /**< pointer to current offset in current record */
size_t current_offset; /**< current offset */
} rcs_iterator_t;
extern rcs_iterator_t rcs_iterator_create (rcs_record_set_t *, rcs_record_t *);
extern void rcs_iterator_write (rcs_iterator_t *, void *, size_t);
extern void rcs_iterator_read (rcs_iterator_t *, void *, size_t);
extern void rcs_iterator_skip (rcs_iterator_t *, size_t);
extern void rcs_iterator_reset (rcs_iterator_t *);
extern bool rcs_iterator_finished (rcs_iterator_t *);
#endif /* !RCS_ITERATOR_H */

637
jerry-core/rcs/rcs-records.c
View File

@ -1,637 +0,0 @@
/* Copyright 2015-2016 Samsung Electronics Co., Ltd.
* Copyright 2015-2016 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rcs-records.h"
#include "rcs-allocator.h"
#include "rcs-cpointer.h"
#include "rcs-iterator.h"
#include "jrt-bit-fields.h"
/**
* Set value of the record's field with specified offset and width.
*/
static void
rcs_record_set_field (rcs_record_t *rec_p, /**< record */
uint32_t field_pos, /**< offset, in bits */
uint32_t field_width, /**< width, in bits */
size_t value) /**< 32-bit unsigned integer value */
{
rcs_check_record_alignment (rec_p);
JERRY_ASSERT (sizeof (uint32_t) <= RCS_DYN_STORAGE_LENGTH_UNIT);
JERRY_ASSERT (field_pos + field_width <= RCS_DYN_STORAGE_LENGTH_UNIT * JERRY_BITSINBYTE);
uint32_t prev_value = *(uint32_t *) rec_p;
*(uint32_t *) rec_p = JRT_SET_BIT_FIELD_VALUE (uint32_t, prev_value, value, field_pos, field_width);
} /* rcs_record_set_field */
/**
* Set the record's type identifier.
*/
void
rcs_record_set_type (rcs_record_t *rec_p, /**< record */
rcs_record_type_t type) /**< record type */
{
JERRY_ASSERT (RCS_RECORD_TYPE_IS_VALID (type));
rcs_record_set_field (rec_p, RCS_HEADER_TYPE_POS, RCS_HEADER_TYPE_WIDTH, type);
} /* rcs_record_set_type */
/**
* Set previous record for the records.
*/
void
rcs_record_set_prev (rcs_record_set_t *rec_sec_p, /**< recordset */
rcs_record_t *rec_p, /**< record */
rcs_record_t *prev_p) /**< prev record */
{
uint8_t begin_pos;
switch (rcs_record_get_type (rec_p))
{
case RCS_RECORD_TYPE_CHARSET:
{
rcs_cpointer_t prev_cpointer = rcs_cpointer_compress (prev_p);
rcs_iterator_t it_ctx = rcs_iterator_create (rec_sec_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_DYN_STORAGE_LENGTH_UNIT);
rcs_iterator_write (&it_ctx, &prev_cpointer.u.packed_value, sizeof (uint16_t));
return;
}
case RCS_RECORD_TYPE_FREE:
{
begin_pos = RCS_FREE_HEADER_PREV_POS;
break;
}
case RCS_RECORD_TYPE_MAGIC_STR:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
begin_pos = RCS_MAGIC_STR_HEADER_PREV_POS;
break;
}
case RCS_RECORD_TYPE_NUMBER:
{
begin_pos = RCS_NUMBER_HEADER_PREV_POS;
break;
}
default:
{
JERRY_UNREACHABLE ();
}
}
rcs_cpointer_t cpointer = rcs_cpointer_compress (prev_p);
rcs_record_set_field (rec_p, begin_pos, RCS_CPOINTER_WIDTH, cpointer.u.packed_value);
} /* rcs_record_set_prev */
/**
* Set size of the records.
*/
void
rcs_record_set_size (rcs_record_t *rec_p, /**< recordset */
size_t size) /**< record size */
{
rcs_record_type_t type = rcs_record_get_type (rec_p);
if (RCS_RECORD_TYPE_IS_CHARSET (type))
{
JERRY_ASSERT (JERRY_ALIGNUP (size, RCS_DYN_STORAGE_LENGTH_UNIT) == size);
rcs_record_set_field (rec_p,
RCS_CHARSET_HEADER_LENGTH_POS,
RCS_CHARSET_HEADER_LENGTH_WIDTH,
size >> RCS_DYN_STORAGE_LENGTH_UNIT_LOG);
return;
}
if (RCS_RECORD_TYPE_IS_FREE (type))
{
JERRY_ASSERT (JERRY_ALIGNUP (size, RCS_DYN_STORAGE_LENGTH_UNIT) == size);
rcs_record_set_field (rec_p,
RCS_FREE_HEADER_LENGTH_POS,
RCS_FREE_HEADER_LENGTH_WIDTH,
size >> RCS_DYN_STORAGE_LENGTH_UNIT_LOG);
return;
}
JERRY_ASSERT (rcs_record_get_size (rec_p) == size);
} /* rcs_record_set_size */
/**
* Set the count of the alignment bytes at the end of record.
*/
void
rcs_record_set_alignment_bytes_count (rcs_record_t *rec_p, /**< record */
size_t count) /**< align bytes */
{
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (rec_p));
rcs_record_set_field (rec_p, RCS_CHARSET_HEADER_ALIGN_POS, RCS_CHARSET_HEADER_ALIGN_WIDTH, count);
} /* rcs_record_set_alignment_bytes_count */
/**
* Set the hash value of the record.
*/
void
rcs_record_set_hash (rcs_record_t *rec_p, /**< record */
lit_string_hash_t hash) /**< hash value */
{
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (rec_p));
rcs_record_set_field (rec_p, RCS_CHARSET_HEADER_HASH_POS, RCS_CHARSET_HEADER_HASH_WIDTH, hash);
} /* rcs_record_set_hash */
/**
* Set the charset of the record.
*/
void
rcs_record_set_charset (rcs_record_set_t *rec_set_p, /**< recordset containing the records */
rcs_record_t *rec_p, /**< record */
const lit_utf8_byte_t *str_p, /**< buffer containing characters to set */
lit_utf8_size_t size) /**< size of the buffer in bytes */
{
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (rec_p));
JERRY_ASSERT (RCS_CHARSET_HEADER_SIZE + size
== rcs_record_get_size (rec_p) - rcs_record_get_alignment_bytes_count (rec_p));
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t str_len = rcs_record_get_length (rec_p);
lit_utf8_size_t i;
for (i = 0; i < str_len; ++i)
{
rcs_iterator_write (&it_ctx, (void *)(str_p + i), sizeof (lit_utf8_byte_t));
rcs_iterator_skip (&it_ctx, sizeof (lit_utf8_byte_t));
}
} /* rcs_record_set_charset */
/**
* Set the magic string id of the record.
*/
void
rcs_record_set_magic_str_id (rcs_record_t *rec_p, /**< record */
lit_magic_string_id_t id) /**< magic string id */
{
JERRY_ASSERT (RCS_RECORD_IS_MAGIC_STR (rec_p));
rcs_record_set_field (rec_p, RCS_MAGIC_STR_HEADER_ID_POS, RCS_MAGIC_STR_HEADER_ID_WIDTH, id);
} /* rcs_record_set_magic_str_id */
/**
* Set the external magic string id of the record.
*/
void
rcs_record_set_magic_str_ex_id (rcs_record_t *rec_p, /**< record */
lit_magic_string_ex_id_t id) /**< external magic string id */
{
JERRY_ASSERT (RCS_RECORD_IS_MAGIC_STR_EX (rec_p));
rcs_record_set_field (rec_p, RCS_MAGIC_STR_HEADER_ID_POS, RCS_MAGIC_STR_HEADER_ID_WIDTH, id);
} /* rcs_record_set_magic_str_ex_id */
/**
* Get value of the record's field with specified offset and width.
*
* @return field's 32-bit unsigned integer value
*/
static uint32_t
rcs_record_get_field (rcs_record_t *rec_p, /**< record */
uint32_t field_pos, /**< offset, in bits */
uint32_t field_width) /**< width, in bits */
{
rcs_check_record_alignment (rec_p);
JERRY_ASSERT (sizeof (uint32_t) <= RCS_DYN_STORAGE_LENGTH_UNIT);
JERRY_ASSERT (field_pos + field_width <= RCS_DYN_STORAGE_LENGTH_UNIT * JERRY_BITSINBYTE);
uint32_t value = *(uint32_t *) rec_p;
return JRT_EXTRACT_BIT_FIELD (uint32_t, value, field_pos, field_width);
} /* rcs_record_get_field */
/**
* Get value of the record's pointer field with specified offset and width.
*
* @return pointer to record
*/
static rcs_record_t *
rcs_record_get_pointer (rcs_record_t *rec_p, /**< record */
uint32_t field_pos, /**< offset, in bits */
uint32_t field_width) /**< width, in bits */
{
rcs_cpointer_t cpointer;
uint16_t value = (uint16_t) rcs_record_get_field (rec_p, field_pos, field_width);
JERRY_ASSERT (sizeof (cpointer) == sizeof (cpointer.u.value));
JERRY_ASSERT (sizeof (value) == sizeof (cpointer.u.value));
cpointer.u.packed_value = value;
return rcs_cpointer_decompress (cpointer);
} /* rcs_record_get_pointer */
/**
* Get the record's type identifier.
*
* @return record type identifier
*/
rcs_record_type_t
rcs_record_get_type (rcs_record_t *rec_p) /**< record */
{
JERRY_STATIC_ASSERT (sizeof (rcs_record_type_t) * JERRY_BITSINBYTE >= RCS_HEADER_TYPE_WIDTH,
bits_in_rcs_record_type_t_must_be_greater_than_or_equal_to_RCS_HEADER_TYPE_WIDTH);
return (rcs_record_type_t) rcs_record_get_field (rec_p, RCS_HEADER_TYPE_POS, RCS_HEADER_TYPE_WIDTH);
} /* rcs_record_get_type */
/**
* Get previous record for the records.
*
* @return previous record
*/
rcs_record_t *
rcs_record_get_prev (rcs_record_set_t *rec_sec_p, /**< recordset */
rcs_record_t *rec_p) /**< record */
{
uint8_t begin_pos;
switch (rcs_record_get_type (rec_p))
{
case RCS_RECORD_TYPE_CHARSET:
{
rcs_cpointer_t cpointer;
rcs_iterator_t it_ctx = rcs_iterator_create (rec_sec_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_DYN_STORAGE_LENGTH_UNIT);
rcs_iterator_read (&it_ctx, &cpointer.u.packed_value, sizeof (uint16_t));
return rcs_cpointer_decompress (cpointer);
}
case RCS_RECORD_TYPE_FREE:
{
begin_pos = RCS_FREE_HEADER_PREV_POS;
break;
}
case RCS_RECORD_TYPE_MAGIC_STR:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
begin_pos = RCS_MAGIC_STR_HEADER_PREV_POS;
break;
}
case RCS_RECORD_TYPE_NUMBER:
{
begin_pos = RCS_NUMBER_HEADER_PREV_POS;
break;
}
default:
{
JERRY_UNREACHABLE ();
}
}
return rcs_record_get_pointer (rec_p, begin_pos, RCS_CPOINTER_WIDTH);
} /* rcs_record_get_prev */
/**
* Get the count of the alignment bytes at the end of record.
* These bytes are needed to align the record to RCS_DYN_STORAGE_ALIGNMENT.
*
* @return alignment bytes count
*/
size_t
rcs_record_get_alignment_bytes_count (rcs_record_t *rec_p) /**< record */
{
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (rec_p));
return rcs_record_get_field (rec_p, RCS_CHARSET_HEADER_ALIGN_POS, RCS_CHARSET_HEADER_ALIGN_WIDTH);
} /* rcs_record_get_alignment_bytes_count */
/**
* Get hash value of the record's charset.
*
* @return hash value of the string
*/
lit_string_hash_t
rcs_record_get_hash (rcs_record_t *rec_p) /**< record */
{
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (rec_p));
return (lit_string_hash_t) rcs_record_get_field (rec_p, RCS_CHARSET_HEADER_HASH_POS, RCS_CHARSET_HEADER_HASH_WIDTH);
} /* rcs_record_get_hash */
/**
* Get header size of the records.
*
* @return size of the header in bytes
*/
size_t
rcs_header_get_size (rcs_record_t *rec_p) /**< record */
{
if (RCS_RECORD_IS_CHARSET (rec_p))
{
return RCS_CHARSET_HEADER_SIZE;
}
return RCS_DYN_STORAGE_LENGTH_UNIT;
} /* rcs_header_get_size */
/**
* Get size of the records.
*
* @return size of the record in bytes
*/
size_t
rcs_record_get_size (rcs_record_t *rec_p) /**< record */
{
switch (rcs_record_get_type (rec_p))
{
case RCS_RECORD_TYPE_CHARSET:
{
size_t size = rcs_record_get_field (rec_p, RCS_CHARSET_HEADER_LENGTH_POS, RCS_CHARSET_HEADER_LENGTH_WIDTH);
return (size * RCS_DYN_STORAGE_LENGTH_UNIT);
}
case RCS_RECORD_TYPE_FREE:
{
size_t size = rcs_record_get_field (rec_p, RCS_FREE_HEADER_LENGTH_POS, RCS_FREE_HEADER_LENGTH_WIDTH);
return (size * RCS_DYN_STORAGE_LENGTH_UNIT);
}
case RCS_RECORD_TYPE_NUMBER:
{
return (RCS_DYN_STORAGE_LENGTH_UNIT + sizeof (ecma_number_t));
}
case RCS_RECORD_TYPE_MAGIC_STR:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
return RCS_DYN_STORAGE_LENGTH_UNIT;
}
default:
{
JERRY_UNREACHABLE ();
return 0;
}
}
} /* rcs_record_get_size */
/**
* Get the length of the string, which is contained inside the record.
*
* @return length of the string (bytes count)
*/
lit_utf8_size_t
rcs_record_get_length (rcs_record_t *rec_p) /**< record */
{
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (rec_p));
size_t record_size = rcs_record_get_size (rec_p);
size_t align_count = rcs_record_get_alignment_bytes_count (rec_p);
return (lit_utf8_size_t) (record_size - RCS_CHARSET_HEADER_SIZE - align_count);
} /* rcs_record_get_length */
/**
* Get magic string id which is held by the record.
*
* @return magic string id
*/
lit_magic_string_id_t
rcs_record_get_magic_str_id (rcs_record_t *rec_p) /**< record */
{
JERRY_ASSERT (RCS_RECORD_IS_MAGIC_STR (rec_p));
return (lit_magic_string_id_t) rcs_record_get_field (rec_p,
RCS_MAGIC_STR_HEADER_ID_POS,
RCS_MAGIC_STR_HEADER_ID_WIDTH);
} /* rcs_record_get_magic_str_id */
/**
* Get external magic string id which is held by the record.
*
* @return external magic string id
*/
lit_magic_string_ex_id_t
rcs_record_get_magic_str_ex_id (rcs_record_t *rec_p) /**< record */
{
JERRY_ASSERT (RCS_RECORD_IS_MAGIC_STR_EX (rec_p));
return (lit_magic_string_ex_id_t) rcs_record_get_field (rec_p,
RCS_MAGIC_STR_HEADER_ID_POS,
RCS_MAGIC_STR_HEADER_ID_WIDTH);
} /* rcs_record_get_magic_str_ex_id */
/**
* Get the number which is held by the record.
*
* @return number
*/
ecma_number_t
rcs_record_get_number (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *rec_p) /**< record */
{
JERRY_ASSERT (RCS_RECORD_IS_NUMBER (rec_p));
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_NUMBER_HEADER_SIZE);
ecma_number_t value;
rcs_iterator_read (&it_ctx, &value, sizeof (ecma_number_t));
return value;
} /* rcs_record_get_number */
/**
* Get the characters which are stored to the record.
*
* @return number of code units written to the buffer
*/
lit_utf8_size_t
rcs_record_get_charset (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *rec_p, /**< record */
const lit_utf8_byte_t *buff_p, /**< output buffer */
size_t buff_size) /**< size of the output buffer in bytes */
{
JERRY_ASSERT (RCS_RECORD_IS_CHARSET (rec_p));
JERRY_ASSERT (buff_p && buff_size >= sizeof (lit_utf8_byte_t));
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t str_len = rcs_record_get_length (rec_p);
lit_utf8_size_t i;
for (i = 0; i < str_len && buff_size > 0; ++i)
{
rcs_iterator_read (&it_ctx, (void *)(buff_p + i), sizeof (lit_utf8_byte_t));
rcs_iterator_skip (&it_ctx, sizeof (lit_utf8_byte_t));
buff_size -= sizeof (lit_utf8_byte_t);
}
return i;
} /* rcs_record_get_charset */
/**
* Get the first record of the recordset.
*
* @return pointer of the first record of the recordset
*/
rcs_record_t *
rcs_record_get_first (rcs_record_set_t *rec_set_p) /**< recordset */
{
rcs_chunked_list_node_t *first_node_p = rcs_chunked_list_get_first (rec_set_p);
if (first_node_p == NULL)
{
return NULL;
}
return (rcs_record_t *) rcs_get_node_data_space (rec_set_p, first_node_p);
} /* rcs_record_get_first */
/**
* Get record, next to the specified.
*
* @return pointer to the next record
*/
rcs_record_t *
rcs_record_get_next (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *rec_p) /**< record */
{
rcs_chunked_list_node_t *node_p = rcs_chunked_list_get_node_from_pointer (rec_set_p, rec_p);
const uint8_t *data_space_begin_p = rcs_get_node_data_space (rec_set_p, node_p);
const size_t data_space_size = rcs_get_node_data_space_size ();
const uint8_t *record_start_p = (const uint8_t *) rec_p;
const size_t record_size = rcs_record_get_size (rec_p);
const size_t record_offset_in_node = (size_t) (record_start_p - data_space_begin_p);
const size_t node_size_left = data_space_size - record_offset_in_node;
if (node_size_left > record_size)
{
return (rcs_record_t *) (record_start_p + record_size);
}
node_p = rcs_chunked_list_get_next (node_p);
JERRY_ASSERT (node_p != NULL || record_size == node_size_left);
size_t record_size_left = record_size - node_size_left;
while (record_size_left >= data_space_size)
{
JERRY_ASSERT (node_p != NULL);
node_p = rcs_chunked_list_get_next (node_p);
record_size_left -= data_space_size;
}
if (node_p == NULL)
{
JERRY_ASSERT (record_size_left == 0);
return NULL;
}
return (rcs_record_t *) (rcs_get_node_data_space (rec_set_p, node_p) + record_size_left);
} /* rcs_record_get_next */
/**
* Compares two charset records for equality.
*
* @return true if strings inside records are equal
* false otherwise
*/
bool
rcs_record_is_equal (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *l_rec_p, /**< left record */
rcs_record_t *r_rec_p) /**< rigth record */
{
size_t l_rec_length = rcs_record_get_length (l_rec_p);
size_t r_rec_length = rcs_record_get_length (r_rec_p);
if (l_rec_length != r_rec_length)
{
return false;
}
rcs_iterator_t l_rec_it_ctx = rcs_iterator_create (rec_set_p, l_rec_p);
rcs_iterator_t r_rec_it_ctx = rcs_iterator_create (rec_set_p, r_rec_p);
rcs_iterator_skip (&l_rec_it_ctx, RCS_CHARSET_HEADER_SIZE);
rcs_iterator_skip (&r_rec_it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t i;
for (i = 0; i < l_rec_length; ++i)
{
lit_utf8_byte_t l_chr;
lit_utf8_byte_t r_chr;
rcs_iterator_read (&l_rec_it_ctx, &l_chr, sizeof (lit_utf8_byte_t));
rcs_iterator_read (&r_rec_it_ctx, &r_chr, sizeof (lit_utf8_byte_t));
if (l_chr != r_chr)
{
return false;
}
rcs_iterator_skip (&l_rec_it_ctx, sizeof (lit_utf8_byte_t));
rcs_iterator_skip (&r_rec_it_ctx, sizeof (lit_utf8_byte_t));
}
return true;
} /* rcs_record_is_equal */
/**
* Compare a record with a string (which could contain '\0' characters) for equality.
*
* @return true if compared instances are equal
* false otherwise
*/
bool
rcs_record_is_equal_charset (rcs_record_set_t *rec_set_p, /**< recordset */
rcs_record_t *rec_p, /**< record */
const lit_utf8_byte_t *str_p, /**< string to compare with */
lit_utf8_size_t str_size) /**< length of the string */
{
JERRY_ASSERT (str_p != NULL);
size_t rec_length = rcs_record_get_length (rec_p);
if (rec_length != str_size)
{
return false;
}
rcs_iterator_t it_ctx = rcs_iterator_create (rec_set_p, rec_p);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t i;
for (i = 0; i < rec_length; ++i)
{
lit_utf8_byte_t chr;
rcs_iterator_read (&it_ctx, &chr, sizeof (lit_utf8_byte_t));
if (chr != str_p[i])
{
return false;
}
rcs_iterator_skip (&it_ctx, sizeof (lit_utf8_byte_t));
}
return true;
} /* rcs_record_is_equal_charset */

169
jerry-core/rcs/rcs-records.h
View File

@ -1,169 +0,0 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
* Copyright 2015 University of Szeged
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RCS_RECORDS_H
#define RCS_RECORDS_H
#include "ecma-globals.h"
#define RCS_RECORD_TYPE_FIRST RCS_RECORD_TYPE_CHARSET
#define RCS_RECORD_TYPE_LAST RCS_RECORD_TYPE_NUMBER
#define RCS_RECORD_TYPE_MIN RCS_RECORD_TYPE_FREE
#define RCS_RECORD_TYPE_MAX RCS_RECORD_TYPE_NUMBER
#define RCS_RECORD_TYPE_IS_FREE(type) ((type) == RCS_RECORD_TYPE_FREE)
#define RCS_RECORD_TYPE_IS_NUMBER(type) ((type) == RCS_RECORD_TYPE_NUMBER)
#define RCS_RECORD_TYPE_IS_CHARSET(type) ((type) == RCS_RECORD_TYPE_CHARSET)
#define RCS_RECORD_TYPE_IS_MAGIC_STR(type) ((type) == RCS_RECORD_TYPE_MAGIC_STR)
#define RCS_RECORD_TYPE_IS_MAGIC_STR_EX(type) ((type) == RCS_RECORD_TYPE_MAGIC_STR_EX)
#define RCS_RECORD_TYPE_IS_VALID(type) ((type) <= RCS_RECORD_TYPE_MAX)
#define RCS_RECORD_IS_FREE(rec) (RCS_RECORD_TYPE_IS_FREE (rcs_record_get_type (rec)))
#define RCS_RECORD_IS_NUMBER(rec) (RCS_RECORD_TYPE_IS_NUMBER (rcs_record_get_type (rec)))
#define RCS_RECORD_IS_CHARSET(rec) (RCS_RECORD_TYPE_IS_CHARSET (rcs_record_get_type (rec)))
#define RCS_RECORD_IS_MAGIC_STR(rec) (RCS_RECORD_TYPE_IS_MAGIC_STR (rcs_record_get_type (rec)))
#define RCS_RECORD_IS_MAGIC_STR_EX(rec) (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (rcs_record_get_type (rec)))
/**
* Common header informations.
*/
#define RCS_HEADER_TYPE_POS 0u
#define RCS_HEADER_TYPE_WIDTH 4u
#define RCS_HEADER_FIELD_BEGIN_POS (RCS_HEADER_TYPE_POS + RCS_HEADER_TYPE_WIDTH)
/**
* Number record
* Doesn't hold any characters, holds a number.
* Numbers from source code are represented as number literals.
*
* Layout:
* ------- header -----------------------
* type (4 bits)
* padding (12 bits)
* pointer to prev (16 bits)
* --------------------------------------
* ecma_number_t
*/
#define RCS_NUMBER_HEADER_SIZE RCS_DYN_STORAGE_LENGTH_UNIT
#define RCS_NUMBER_HEADER_PREV_POS (RCS_HEADER_FIELD_BEGIN_POS + 12u)
/**
* Charset record
*
* layout:
* ------- header -----------------------
* type (4 bits)
* alignment (2 bits)
* unused (2 bits)
* hash (8 bits)
* length (16 bits)
* pointer to prev (16 bits)
* ------- characters -------------------
* ...
* chars
* ....
* ------- alignment bytes --------------
* unused bytes (their count is specified
* by 'alignment' field in header)
* --------------------------------------
*/
#define RCS_CHARSET_HEADER_SIZE (RCS_DYN_STORAGE_LENGTH_UNIT + RCS_DYN_STORAGE_LENGTH_UNIT / 2)
#define RCS_CHARSET_HEADER_ALIGN_POS RCS_HEADER_FIELD_BEGIN_POS
#define RCS_CHARSET_HEADER_ALIGN_WIDTH RCS_DYN_STORAGE_LENGTH_UNIT_LOG
#define RCS_CHARSET_HEADER_UNUSED_POS (RCS_CHARSET_HEADER_ALIGN_POS + RCS_CHARSET_HEADER_ALIGN_WIDTH)
#define RCS_CHARSET_HEADER_UNUSED_WIDTH 2u
#define RCS_CHARSET_HEADER_HASH_POS (RCS_CHARSET_HEADER_UNUSED_POS + RCS_CHARSET_HEADER_UNUSED_WIDTH)
#define RCS_CHARSET_HEADER_HASH_WIDTH 8u
#define RCS_CHARSET_HEADER_LENGTH_POS (RCS_CHARSET_HEADER_HASH_POS + RCS_CHARSET_HEADER_HASH_WIDTH)
#define RCS_CHARSET_HEADER_LENGTH_WIDTH 16u
#define RCS_CHARSET_HEADER_PREV_POS (RCS_CHARSET_HEADER_LENGTH_POS + RCS_CHARSET_HEADER_LENGTH_WIDTH)
/**
* Magic string record
* Doesn't hold any characters. Corresponding string is identified by its id.
*
* Layout:
* ------- header -----------------------
* type (4 bits)
* magic string id (12 bits)
* pointer to prev (16 bits)
* --------------------------------------
*/
#define RCS_MAGIC_STR_HEADER_SIZE RCS_DYN_STORAGE_LENGTH_UNIT
#define RCS_MAGIC_STR_HEADER_ID_POS RCS_HEADER_FIELD_BEGIN_POS
#define RCS_MAGIC_STR_HEADER_ID_WIDTH 12u
#define RCS_MAGIC_STR_HEADER_PREV_POS (RCS_MAGIC_STR_HEADER_ID_POS + RCS_MAGIC_STR_HEADER_ID_WIDTH)
/**
* Free record
* Doesn't hold any data.
*
* Layout:
* ------- header -----------------------
* type (4 bits)
* length (12 bits)
* pointer to prev (16 bits)
* --------------------------------------
*/
#define RCS_FREE_HEADER_SIZE RCS_DYN_STORAGE_LENGTH_UNIT
#define RCS_FREE_HEADER_LENGTH_POS RCS_HEADER_FIELD_BEGIN_POS
#define RCS_FREE_HEADER_LENGTH_WIDTH (14u - RCS_DYN_STORAGE_LENGTH_UNIT_LOG)
#define RCS_FREE_HEADER_PREV_POS (RCS_FREE_HEADER_LENGTH_POS + RCS_FREE_HEADER_LENGTH_WIDTH)
/*
* Setters
*/
extern void rcs_record_set_type (rcs_record_t *, rcs_record_type_t);
extern void rcs_record_set_prev (rcs_record_set_t *, rcs_record_t *, rcs_record_t *);
extern void rcs_record_set_size (rcs_record_t *, size_t);
extern void rcs_record_set_alignment_bytes_count (rcs_record_t *, size_t);
extern void rcs_record_set_hash (rcs_record_t *, lit_string_hash_t);
extern void rcs_record_set_charset (rcs_record_set_t *, rcs_record_t *, const lit_utf8_byte_t *, lit_utf8_size_t);
extern void rcs_record_set_magic_str_id (rcs_record_t *, lit_magic_string_id_t);
extern void rcs_record_set_magic_str_ex_id (rcs_record_t *, lit_magic_string_ex_id_t);
/*
* Getters
*/
extern rcs_record_type_t rcs_record_get_type (rcs_record_t *);
extern rcs_record_t *rcs_record_get_prev (rcs_record_set_t *, rcs_record_t *);
extern size_t rcs_record_get_size (rcs_record_t *);
extern size_t rcs_header_get_size (rcs_record_t *);
extern size_t rcs_record_get_alignment_bytes_count (rcs_record_t *);
extern lit_string_hash_t rcs_record_get_hash (rcs_record_t *);
extern lit_utf8_size_t rcs_record_get_length (rcs_record_t *);
extern lit_utf8_size_t rcs_record_get_charset (rcs_record_set_t *, rcs_record_t *, const lit_utf8_byte_t *, size_t);
extern lit_magic_string_id_t rcs_record_get_magic_str_id (rcs_record_t *);
extern lit_magic_string_ex_id_t rcs_record_get_magic_str_ex_id (rcs_record_t *);
extern ecma_number_t rcs_record_get_number (rcs_record_set_t *, rcs_record_t *);
extern rcs_record_t *rcs_record_get_first (rcs_record_set_t *);
extern rcs_record_t *rcs_record_get_next (rcs_record_set_t *, rcs_record_t *);
extern bool rcs_record_is_equal (rcs_record_set_t *, rcs_record_t *, rcs_record_t *);
extern bool rcs_record_is_equal_charset (rcs_record_set_t *, rcs_record_t *, const lit_utf8_byte_t *, lit_utf8_size_t);
#endif /* !RCS_RECORDS_H */

8
jerry-core/vm/vm.c
View File

@ -29,8 +29,8 @@
#include "ecma-objects-general.h"
#include "ecma-regexp-object.h"
#include "ecma-try-catch-macro.h"
#include "lit-literal-storage.h"
#include "opcodes.h"
#include "rcs-records.h"
#include "vm.h"
#include "vm-stack.h"
@ -269,7 +269,7 @@ vm_construct_literal_object (vm_frame_ctx_t *frame_ctx_p, /**< frame context */
lit_cpointer_t lit_cp) /**< literal */
{
ecma_compiled_code_t *bytecode_p = ECMA_GET_NON_NULL_POINTER (ecma_compiled_code_t,
lit_cp.u.value.base_cp);
lit_cp);
bool is_function = ((bytecode_p->status_flags & CBC_CODE_FLAGS_FUNCTION) != 0);
if (is_function)
@ -390,8 +390,8 @@ enum
else if (literal_index < const_literal_end) \
{ \
lit_cpointer_t lit_cpointer = literal_start_p[literal_index]; \
lit_literal_t lit = rcs_cpointer_decompress (lit_cpointer); \
if (unlikely (RCS_RECORD_IS_NUMBER (lit))) \
lit_literal_t lit = lit_cpointer_decompress (lit_cpointer); \
if (unlikely (LIT_RECORD_IS_NUMBER (lit))) \
{ \
ecma_number_t *number_p = ecma_alloc_number (); \
*number_p = lit_number_literal_get_number (lit); \

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

@ -18,6 +18,7 @@
#define VM_H
#include "ecma-globals.h"
#include "lit-cpointer.h"
#include "jrt.h"
#include "vm-defines.h"

40
tests/unit/test-heap.c
View File

@ -1,4 +1,5 @@
/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -60,7 +61,7 @@ test_heap_give_some_memory_back (mem_try_give_memory_back_severity_t severity)
JERRY_ASSERT (ptrs[i][k] == 0);
}
mem_heap_free_block (ptrs[i]);
mem_heap_free_block_size_stored (ptrs[i]);
ptrs[i] = NULL;
}
}
@ -77,37 +78,18 @@ main (int __attr_unused___ argc,
mem_register_a_try_give_memory_back_callback (test_heap_give_some_memory_back);
mem_heap_print (true, false, true);
mem_heap_print ();
for (uint32_t i = 0; i < test_iters; i++)
{
for (uint32_t j = 0; j < test_sub_iters; j++)
{
if (rand () % 2)
{
size_t size = (size_t) rand () % test_threshold_block_size;
ptrs[j] = (uint8_t*) mem_heap_alloc_block (size,
(rand () % 2) ?
MEM_HEAP_ALLOC_LONG_TERM : MEM_HEAP_ALLOC_SHORT_TERM);
sizes[j] = size;
is_one_chunked[j] = false;
}
else
{
ptrs[j] = (uint8_t*) mem_heap_alloc_chunked_block ((rand () % 2) ?
MEM_HEAP_ALLOC_LONG_TERM : MEM_HEAP_ALLOC_SHORT_TERM);
sizes[j] = mem_heap_get_chunked_block_data_size ();
is_one_chunked[j] = true;
}
size_t size = (size_t) rand () % test_threshold_block_size;
ptrs[j] = (uint8_t*) mem_heap_alloc_block_store_size (size);
sizes[j] = size;
JERRY_ASSERT (sizes[j] == 0 || ptrs[j] != NULL);
memset (ptrs[j], 0, sizes[j]);
if (is_one_chunked[j])
{
JERRY_ASSERT (ptrs[j] != NULL
&& mem_heap_get_chunked_block_start (ptrs[j] + (size_t) rand () % sizes[j]) == ptrs[j]);
}
}
// mem_heap_print (true);
@ -121,20 +103,14 @@ main (int __attr_unused___ argc,
JERRY_ASSERT (ptrs[j][k] == 0);
}
if (is_one_chunked[j])
{
JERRY_ASSERT (sizes[j] == 0
|| mem_heap_get_chunked_block_start (ptrs[j] + (size_t) rand () % sizes[j]) == ptrs[j]);
}
mem_heap_free_block (ptrs[j]);
mem_heap_free_block_size_stored (ptrs[j]);
ptrs[j] = NULL;
}
}
}
mem_heap_print (true, false, true);
mem_heap_print ();
return 0;
} /* main */

4
tests/unit/test-literal-storage.c
View File

@ -16,7 +16,6 @@
#include "ecma-helpers.h"
#include "lit-literal.h"
#include "lit-literal-storage.h"
#include "rcs-records.h"
#include "test-common.h"
// Iterations count
@ -132,9 +131,6 @@ main (int __attr_unused___ argc,
// Check empty string exists
JERRY_ASSERT (lit_find_literal_by_utf8_string (NULL, 0));
rcs_chunked_list_cleanup (&rcs_lit_storage);
JERRY_ASSERT (rcs_record_get_first (&rcs_lit_storage) == NULL);
}
lit_finalize ();

14
tests/unit/test-poolman.c
View File

@ -1,4 +1,5 @@
/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -47,8 +48,7 @@ main (int __attr_unused___ argc,
for (size_t j = 0; j < subiters; j++)
{
ptrs[j] = mem_pools_alloc ();
// JERRY_ASSERT (ptrs[j] != NULL);
ptrs[j] = (uint8_t *) mem_pools_alloc ();
if (ptrs[j] != NULL)
{
@ -85,11 +85,11 @@ main (int __attr_unused___ argc,
printf ("Pools stats:\n");
printf (" Chunk size: %u\n"
" Pools: %lu\n"
" Allocated chunks: %lu\n"
" Free chunks: %lu\n"
" Peak pools: %lu\n"
" Peak allocated chunks: %lu\n\n",
" Pools: %zu\n"
" Allocated chunks: %zu\n"
" Free chunks: %zu\n"
" Peak pools: %zu\n"
" Peak allocated chunks: %zu\n\n",
MEM_POOL_CHUNK_SIZE,
stats.pools_count,
stats.allocated_chunks,