jerryscript/jerry-core/rcs/rcs-recordset.h

/* 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 */