Recordset dynamic storage.
JerryScript-DCO-1.0-Signed-off-by: Ruben Ayrapetyan r.ayrapetyan@samsung.com
This commit is contained in:
Ruben Ayrapetyan
@@ -0,0 +1,274 @@
|
||||
/* 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_RECORDSET_H
|
||||
#define RCS_RECORDSET_H
|
||||
|
||||
#include "jrt.h"
|
||||
#include "jrt-bit-fields.h"
|
||||
#include "mem-allocator.h"
|
||||
#include "rcs-chunked-list.h"
|
||||
|
||||
/** \addtogroup recordset Recordset
|
||||
* @{
|
||||
*
|
||||
* Non-contiguous container abstraction with iterator.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Logarithm of a dynamic storage unit alignment
|
||||
*/
|
||||
#define RCS_DYN_STORAGE_ALIGNMENT_LOG (2u)
|
||||
|
||||
/**
|
||||
* Dynamic storage unit alignment
|
||||
*/
|
||||
#define RCS_DYN_STORAGE_ALIGNMENT (1ull << RCS_DYN_STORAGE_ALIGNMENT_LOG)
|
||||
|
||||
/**
|
||||
* Unit of length
|
||||
*
|
||||
* See also:
|
||||
* rcs_dyn_storage_length_t
|
||||
*/
|
||||
#define RCS_DYN_STORAGE_LENGTH_UNIT (4u)
|
||||
|
||||
/**
|
||||
* Dynamic storage
|
||||
*
|
||||
* Note:
|
||||
* Static C++ constructors / desctructors are supposed to be not supported.
|
||||
* So, initialization / destruction is implemented through init / finalize
|
||||
* static functions.
|
||||
*/
|
||||
class rcs_recordset_t
|
||||
{
|
||||
public:
|
||||
/* Constructor */
|
||||
void init (void)
|
||||
{
|
||||
_chunk_list.init ();
|
||||
|
||||
JERRY_ASSERT (_chunk_list.get_data_space_size () % RCS_DYN_STORAGE_LENGTH_UNIT == 0);
|
||||
} /* init */
|
||||
|
||||
/* Destructor */
|
||||
void finalize (void)
|
||||
{
|
||||
_chunk_list.free ();
|
||||
} /* finalize */
|
||||
|
||||
/**
|
||||
* Record type
|
||||
*/
|
||||
class record_t
|
||||
{
|
||||
public:
|
||||
typedef uint8_t type_t;
|
||||
|
||||
type_t get_type (void) const;
|
||||
void set_type (type_t type);
|
||||
|
||||
/**
|
||||
* Dynamic storage-specific extended compressed pointer
|
||||
*
|
||||
* Note:
|
||||
* the pointer can represent addresses aligned by RCS_DYN_STORAGE_ALIGNMENT,
|
||||
* while mem_cpointer_t can only represent addressed aligned by MEM_ALIGNMENT.
|
||||
*/
|
||||
struct cpointer_t
|
||||
{
|
||||
static const uint32_t bit_field_width = MEM_CP_WIDTH + MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_ALIGNMENT_LOG;
|
||||
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
mem_cpointer_t base_cp : MEM_CP_WIDTH; /**< pointer to base of addressed area */
|
||||
#if MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_ALIGNMENT_LOG
|
||||
uint16_t ext : (MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_ALIGNMENT_LOG); /**< extension of the basic
|
||||
* compressed pointer
|
||||
* used for more detailed
|
||||
* addressing */
|
||||
#endif /* MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_ALIGNMENT_LOG */
|
||||
} value;
|
||||
uint16_t packed_value;
|
||||
};
|
||||
|
||||
static cpointer_t compress (record_t* pointer_p);
|
||||
static record_t* decompress (cpointer_t pointer_cp);
|
||||
};
|
||||
|
||||
private:
|
||||
/**
|
||||
* Offset of 'type' field, in bits
|
||||
*/
|
||||
static const uint32_t _type_field_pos = 0u;
|
||||
|
||||
/**
|
||||
* Width of 'type' field, in bits
|
||||
*/
|
||||
static const uint32_t _type_field_width = 4u;
|
||||
|
||||
protected:
|
||||
void check_this (void) const;
|
||||
|
||||
uint32_t get_field (uint32_t field_pos, uint32_t field_width) const;
|
||||
void set_field (uint32_t field_pos, uint32_t field_width, size_t value);
|
||||
|
||||
record_t* get_pointer (uint32_t field_pos, uint32_t field_width) const;
|
||||
void set_pointer (uint32_t field_pos, uint32_t field_width, record_t* pointer_p);
|
||||
|
||||
/**
|
||||
* Offset of a derived record's fields, in bits
|
||||
*/
|
||||
static const uint32_t _fields_offset_begin = _type_field_pos + _type_field_width;
|
||||
};
|
||||
private:
|
||||
friend class rcs_record_iterator_t;
|
||||
|
||||
/**
|
||||
* Type identifier for free record
|
||||
*/
|
||||
static const record_t::type_t _free_record_type_id = 0;
|
||||
|
||||
/**
|
||||
* Chunked list used for memory allocation
|
||||
*/
|
||||
rcs_chunked_list_t _chunk_list;
|
||||
|
||||
void alloc_record_in_place (record_t* place_p,
|
||||
size_t free_size,
|
||||
record_t* next_record_p);
|
||||
|
||||
void init_free_record (record_t *free_rec_p, size_t size, record_t *prev_rec_p);
|
||||
bool is_record_free (record_t *record_p);
|
||||
protected:
|
||||
/**
|
||||
* First type identifier that can be used for storage-specific record types
|
||||
*/
|
||||
static const record_t::type_t _first_type_id = _free_record_type_id + 1;
|
||||
|
||||
/**
|
||||
* Allocate new record of specified type
|
||||
*
|
||||
* @return pointer to the new record
|
||||
*/
|
||||
template<
|
||||
typename T, /**< type of record structure */
|
||||
typename ... SizeArgs> /**< type of arguments of T::size */
|
||||
T* alloc_record (record_t::type_t type, /**< record's type identifier */
|
||||
SizeArgs ... size_args) /**< arguments of T::size */
|
||||
{
|
||||
JERRY_ASSERT (type >= _first_type_id);
|
||||
|
||||
size_t size = T::size (size_args...);
|
||||
|
||||
record_t *prev_rec_p;
|
||||
T* rec_p = static_cast<T*> (alloc_space_for_record (size, &prev_rec_p));
|
||||
|
||||
rec_p->set_type (type);
|
||||
rec_p->set_size (size);
|
||||
rec_p->set_prev (prev_rec_p);
|
||||
|
||||
assert_state_is_correct ();
|
||||
|
||||
return rec_p;
|
||||
} /* alloc_record */
|
||||
|
||||
record_t* alloc_space_for_record (size_t bytes, record_t** out_prev_rec_p);
|
||||
void free_record (record_t* record_p);
|
||||
|
||||
record_t* get_first (void);
|
||||
|
||||
virtual record_t* get_prev (record_t* rec_p);
|
||||
record_t* get_next (record_t* rec_p);
|
||||
virtual void set_prev (record_t* rec_p, record_t *prev_rec_p);
|
||||
|
||||
virtual size_t get_record_size (record_t* rec_p);
|
||||
|
||||
void assert_state_is_correct (void);
|
||||
}; /* rcs_recordset_t */
|
||||
|
||||
/**
|
||||
* Record type
|
||||
*/
|
||||
typedef rcs_recordset_t::record_t rcs_record_t;
|
||||
|
||||
/**
|
||||
* Recordset-specific compressed pointer type
|
||||
*/
|
||||
typedef rcs_record_t::cpointer_t rcs_cpointer_t;
|
||||
|
||||
/**
|
||||
* Record iterator
|
||||
*/
|
||||
class rcs_record_iterator_t
|
||||
{
|
||||
public:
|
||||
rcs_record_iterator_t (rcs_record_t* rec_p);
|
||||
rcs_record_iterator_t (rcs_cpointer_t rec_ext_cp);
|
||||
|
||||
protected:
|
||||
template<typename T> T read (void);
|
||||
template<typename T> void write (T value);
|
||||
|
||||
private:
|
||||
rcs_record_t* _record_start_p; /**< start of current record */
|
||||
uint8_t* _current_pos_p; /**< pointer to current offset in current record */
|
||||
|
||||
rcs_recordset_t *_recordset_p; /**< recordset containing the record */
|
||||
}; /* rcs_record_iterator_t */
|
||||
|
||||
/**
|
||||
* Free record layout description
|
||||
*/
|
||||
class rcs_free_record_t : public rcs_record_t
|
||||
{
|
||||
public:
|
||||
size_t get_size (void) const;
|
||||
void set_size (size_t size);
|
||||
|
||||
rcs_record_t* get_prev (void) const;
|
||||
void set_prev (rcs_record_t* prev_rec_p);
|
||||
private:
|
||||
/**
|
||||
* Offset of 'length' field, in bits
|
||||
*/
|
||||
static const uint32_t _length_field_pos = _fields_offset_begin;
|
||||
|
||||
/**
|
||||
* Width of 'length' field, in bits
|
||||
*/
|
||||
static const uint32_t _length_field_width = 12u;
|
||||
|
||||
/**
|
||||
* Offset of 'previous record' field, in bits
|
||||
*/
|
||||
static const uint32_t _prev_field_pos = _length_field_pos + _length_field_width;
|
||||
|
||||
/**
|
||||
* Width of 'previous record' field, in bits
|
||||
*/
|
||||
static const uint32_t _prev_field_width = rcs_cpointer_t::bit_field_width;
|
||||
};
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#endif /* RCS_RECORDSET_H */
|
||||
Reference in New Issue
Block a user