mirror of
https://github.com/jerryscript-project/jerryscript.git
synced 2025-12-15 16:29:21 +00:00
383 lines
11 KiB
C++
383 lines
11 KiB
C++
/* 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 "mem-allocator.h"
|
|
#include "rcs-recordset.h"
|
|
|
|
#include "test-common.h"
|
|
|
|
// Heap size is 32K
|
|
#define test_heap_size (32 * 1024)
|
|
|
|
// Iterations count
|
|
#define test_iters (64)
|
|
|
|
// Subiterations count
|
|
#define test_sub_iters 64
|
|
|
|
// Threshold size of block to allocate
|
|
#define test_threshold_block_size 8192
|
|
|
|
// Maximum number of elements in a type-one record
|
|
#define test_max_type_one_record_elements 64
|
|
|
|
// Element size in a type-one record
|
|
#define test_element_size_type_one_record (sizeof (uint16_t))
|
|
|
|
class test_rcs_record_type_one_t : public rcs_record_t
|
|
{
|
|
public:
|
|
static size_t size (uint32_t elements_count)
|
|
{
|
|
return JERRY_ALIGNUP (header_size + element_size * elements_count,
|
|
RCS_DYN_STORAGE_LENGTH_UNIT);
|
|
}
|
|
|
|
size_t get_size () const
|
|
{
|
|
return get_field (length_field_pos, length_field_width) * RCS_DYN_STORAGE_LENGTH_UNIT;
|
|
}
|
|
|
|
void set_size (size_t size)
|
|
{
|
|
JERRY_ASSERT (JERRY_ALIGNUP (size, RCS_DYN_STORAGE_ALIGNMENT) == size);
|
|
|
|
set_field (length_field_pos, length_field_width, size >> RCS_DYN_STORAGE_ALIGNMENT_LOG);
|
|
}
|
|
|
|
rcs_record_t* get_prev () const
|
|
{
|
|
return get_pointer (prev_field_pos, prev_field_width);
|
|
}
|
|
|
|
void set_prev (rcs_record_t* prev_rec_p)
|
|
{
|
|
set_pointer (prev_field_pos, prev_field_width, prev_rec_p);
|
|
}
|
|
|
|
private:
|
|
static const uint32_t length_field_pos = _fields_offset_begin;
|
|
static const uint32_t length_field_width = 12u;
|
|
|
|
static const uint32_t prev_field_pos = length_field_pos + length_field_width;
|
|
static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width;
|
|
|
|
static const size_t header_size = 2 * RCS_DYN_STORAGE_LENGTH_UNIT;
|
|
static const size_t element_size = test_element_size_type_one_record;
|
|
};
|
|
|
|
class test_rcs_record_type_two_t : public rcs_record_t
|
|
{
|
|
public:
|
|
static size_t size (void)
|
|
{
|
|
return JERRY_ALIGNUP (header_size, RCS_DYN_STORAGE_LENGTH_UNIT);
|
|
}
|
|
|
|
size_t get_size () const
|
|
{
|
|
return size ();
|
|
}
|
|
|
|
void set_size (size_t size)
|
|
{
|
|
JERRY_ASSERT (size == get_size ());
|
|
}
|
|
|
|
rcs_record_t* get_prev () const
|
|
{
|
|
return get_pointer (prev_field_pos, prev_field_width);
|
|
}
|
|
|
|
void set_prev (rcs_record_t* prev_rec_p)
|
|
{
|
|
set_pointer (prev_field_pos, prev_field_width, prev_rec_p);
|
|
}
|
|
|
|
private:
|
|
static const uint32_t prev_field_pos = _fields_offset_begin;
|
|
static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width;
|
|
|
|
static const size_t header_size = RCS_DYN_STORAGE_LENGTH_UNIT;
|
|
};
|
|
|
|
class test_rcs_recordset_t : public rcs_recordset_t
|
|
{
|
|
public:
|
|
test_rcs_record_type_one_t*
|
|
create_record_type_one (uint32_t elements_count)
|
|
{
|
|
return alloc_record<test_rcs_record_type_one_t, uint32_t> (_record_type_one_id,
|
|
elements_count);
|
|
}
|
|
|
|
void
|
|
free_record_type_one (test_rcs_record_type_one_t* rec_p)
|
|
{
|
|
free_record (rec_p);
|
|
}
|
|
|
|
test_rcs_record_type_two_t*
|
|
create_record_type_two (void)
|
|
{
|
|
return alloc_record<test_rcs_record_type_two_t> (_record_type_two_id);
|
|
}
|
|
|
|
void
|
|
free_record_type_two (test_rcs_record_type_two_t* rec_p)
|
|
{
|
|
free_record (rec_p);
|
|
}
|
|
private:
|
|
static const int _record_type_one_id = _first_type_id + 0;
|
|
static const int _record_type_two_id = _first_type_id + 1;
|
|
|
|
virtual rcs_record_t* get_prev (rcs_record_t* rec_p)
|
|
{
|
|
switch (rec_p->get_type ())
|
|
{
|
|
case _record_type_one_id:
|
|
{
|
|
return (static_cast<test_rcs_record_type_one_t*> (rec_p))->get_prev ();
|
|
}
|
|
case _record_type_two_id:
|
|
{
|
|
return (static_cast<test_rcs_record_type_two_t*> (rec_p))->get_prev ();
|
|
}
|
|
default:
|
|
{
|
|
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
|
|
|
|
return rcs_recordset_t::get_prev (rec_p);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void set_prev (rcs_record_t* rec_p,
|
|
rcs_record_t *prev_rec_p)
|
|
{
|
|
switch (rec_p->get_type ())
|
|
{
|
|
case _record_type_one_id:
|
|
{
|
|
return (static_cast<test_rcs_record_type_one_t*> (rec_p))->set_prev (prev_rec_p);
|
|
}
|
|
case _record_type_two_id:
|
|
{
|
|
return (static_cast<test_rcs_record_type_two_t*> (rec_p))->set_prev (prev_rec_p);
|
|
}
|
|
default:
|
|
{
|
|
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
|
|
|
|
return rcs_recordset_t::set_prev (rec_p, prev_rec_p);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual size_t get_record_size (rcs_record_t* rec_p)
|
|
{
|
|
switch (rec_p->get_type ())
|
|
{
|
|
case _record_type_one_id:
|
|
{
|
|
return (static_cast<test_rcs_record_type_one_t*> (rec_p))->get_size ();
|
|
}
|
|
case _record_type_two_id:
|
|
{
|
|
return (static_cast<test_rcs_record_type_two_t*> (rec_p))->get_size ();
|
|
}
|
|
default:
|
|
{
|
|
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
|
|
|
|
return rcs_recordset_t::get_record_size (rec_p);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
int
|
|
main (int __attr_unused___ argc,
|
|
char __attr_unused___ **argv)
|
|
{
|
|
TEST_INIT ();
|
|
|
|
mem_init ();
|
|
|
|
test_rcs_recordset_t storage;
|
|
storage.init ();
|
|
|
|
for (uint32_t i = 0; i < test_iters; i++)
|
|
{
|
|
test_rcs_record_type_one_t *type_one_records[test_sub_iters];
|
|
uint32_t type_one_record_element_counts[test_sub_iters];
|
|
uint16_t type_one_record_elements[test_sub_iters][test_max_type_one_record_elements];
|
|
int type_one_records_number = 0;
|
|
|
|
test_rcs_record_type_two_t *type_two_records[test_sub_iters];
|
|
int type_two_records_number = 0;
|
|
|
|
for (uint32_t j = 0; j < test_sub_iters; j++)
|
|
{
|
|
if (rand () % 2)
|
|
{
|
|
JERRY_ASSERT (type_one_records_number < test_sub_iters);
|
|
|
|
uint32_t elements_count = ((uint32_t) rand ()) % test_max_type_one_record_elements;
|
|
type_one_record_element_counts[type_one_records_number] = elements_count;
|
|
type_one_records[type_one_records_number] = storage.create_record_type_one (elements_count);
|
|
|
|
JERRY_ASSERT (type_one_records[type_one_records_number] != NULL);
|
|
|
|
rcs_record_iterator_t it (&storage, type_one_records[type_one_records_number]);
|
|
it.skip<uint32_t> (); // skip header
|
|
it.skip<uint32_t> (); // skip header
|
|
for (uint32_t i = 0; i < type_one_record_element_counts[type_one_records_number]; it.skip<uint16_t>(), i++)
|
|
{
|
|
uint16_t val = (uint16_t)rand ();
|
|
type_one_record_elements[type_one_records_number][i] = val;
|
|
it.write (val);
|
|
}
|
|
|
|
JERRY_ASSERT (type_one_records[type_one_records_number] != NULL);
|
|
|
|
it.reset ();
|
|
it.skip<uint32_t> (); // skip header
|
|
it.skip<uint32_t> (); // skip header
|
|
for (uint32_t i = 0; i < type_one_record_element_counts[type_one_records_number]; it.skip<uint16_t>(), i++)
|
|
{
|
|
uint16_t val = type_one_record_elements[type_one_records_number][i];
|
|
JERRY_ASSERT (val == it.read<uint16_t> ());
|
|
}
|
|
|
|
type_one_records_number++;
|
|
}
|
|
else
|
|
{
|
|
JERRY_ASSERT (type_two_records_number < test_sub_iters);
|
|
|
|
type_two_records[type_two_records_number] = storage.create_record_type_two ();
|
|
|
|
JERRY_ASSERT (type_two_records[type_two_records_number] != NULL);
|
|
|
|
type_two_records_number++;
|
|
}
|
|
}
|
|
|
|
while (type_one_records_number + type_two_records_number != 0)
|
|
{
|
|
// Read test
|
|
for (int index_to_free = 0; index_to_free < type_one_records_number; index_to_free++)
|
|
{
|
|
JERRY_ASSERT (type_one_records_number > 0);
|
|
|
|
JERRY_ASSERT (index_to_free >= 0 && index_to_free < type_one_records_number);
|
|
|
|
rcs_record_iterator_t it (&storage, type_one_records[index_to_free]);
|
|
it.skip<uint32_t> (); // skip header
|
|
it.skip<uint32_t> (); // skip header
|
|
for (uint32_t i = 0; i < type_one_record_element_counts[index_to_free]; it.skip<uint16_t>(), i++)
|
|
{
|
|
uint16_t val = type_one_record_elements[index_to_free][i];
|
|
JERRY_ASSERT (it.read <uint16_t> () == val);
|
|
}
|
|
|
|
JERRY_ASSERT (JERRY_ALIGNUP (type_one_record_element_counts[index_to_free]*2 + 8, RCS_DYN_STORAGE_ALIGNMENT) ==
|
|
type_one_records[index_to_free]->get_size ());
|
|
}
|
|
|
|
bool free_type_one;
|
|
|
|
if (type_one_records_number == 0)
|
|
{
|
|
JERRY_ASSERT (type_two_records_number != 0);
|
|
|
|
free_type_one = false;
|
|
}
|
|
else if (type_two_records_number == 0)
|
|
{
|
|
JERRY_ASSERT (type_one_records_number != 0);
|
|
|
|
free_type_one = true;
|
|
}
|
|
else
|
|
{
|
|
free_type_one = ((rand () % 2) != 0);
|
|
}
|
|
|
|
if (free_type_one)
|
|
{
|
|
JERRY_ASSERT (type_one_records_number > 0);
|
|
int index_to_free = (rand () % type_one_records_number);
|
|
|
|
JERRY_ASSERT (index_to_free >= 0 && index_to_free < type_one_records_number);
|
|
|
|
rcs_record_iterator_t it (&storage, type_one_records[index_to_free]);
|
|
it.skip<uint32_t> (); // skip header
|
|
it.skip<uint32_t> (); // skip header
|
|
for (uint32_t i = 0; i < type_one_record_element_counts[index_to_free]; it.skip<uint16_t>(), i++)
|
|
{
|
|
uint16_t val = type_one_record_elements[index_to_free][i];
|
|
JERRY_ASSERT (it.read <uint16_t> () == val);
|
|
}
|
|
|
|
// free the record
|
|
storage.free_record_type_one (type_one_records[index_to_free]);
|
|
|
|
type_one_records_number--;
|
|
while (index_to_free < type_one_records_number)
|
|
{
|
|
type_one_records[index_to_free] = type_one_records[index_to_free + 1];
|
|
type_one_record_element_counts[index_to_free] = type_one_record_element_counts[index_to_free + 1];
|
|
memcpy (type_one_record_elements[index_to_free], type_one_record_elements[index_to_free + 1],
|
|
test_max_type_one_record_elements * test_element_size_type_one_record);
|
|
|
|
index_to_free++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
JERRY_ASSERT (type_two_records_number > 0);
|
|
int index_to_free = (rand () % type_two_records_number);
|
|
|
|
JERRY_ASSERT (index_to_free >= 0 && index_to_free < type_two_records_number);
|
|
|
|
storage.free_record_type_two (type_two_records[index_to_free]);
|
|
|
|
type_two_records_number--;
|
|
while (index_to_free < type_two_records_number)
|
|
{
|
|
type_two_records[index_to_free] = type_two_records[index_to_free + 1];
|
|
|
|
index_to_free++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
storage.finalize ();
|
|
|
|
mem_finalize (true);
|
|
|
|
return 0;
|
|
} /* main */
|
|
|
|
template test_rcs_record_type_one_t *
|
|
rcs_recordset_t::alloc_record<test_rcs_record_type_one_t> (rcs_record_t::type_t, uint32_t);
|
|
|
|
template test_rcs_record_type_two_t *
|
|
rcs_recordset_t::alloc_record<test_rcs_record_type_two_t> (rcs_record_t::type_t);
|