common_log_types.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_LOG_COMMON_LOG_TYPES_HPP_
#define FOEDUS_LOG_COMMON_LOG_TYPES_HPP_
#include <iosfwd>

#include "foedus/assert_nd.hpp"
#include "foedus/compiler.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/epoch.hpp"
#include "foedus/fwd.hpp"
#include "foedus/assorted/assorted_func.hpp"
#include "foedus/log/log_type.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/thread/fwd.hpp"
#include "foedus/xct/fwd.hpp"
#include "foedus/xct/xct_id.hpp"

namespace foedus {
namespace log {

struct LogHeader {
  uint16_t            log_type_code_;  // +2 => 2
  uint16_t            log_length_;     // +2 => 4
  storage::StorageId  storage_id_;     // +4 => 8

  xct::XctId          xct_id_;         // +8 => 16

  LogCode get_type() const ALWAYS_INLINE { return static_cast<LogCode>(log_type_code_); }
  LogCodeKind get_kind() const ALWAYS_INLINE { return get_log_code_kind(get_type()); }

  bool is_valid_type() const { return is_valid_log_type(get_type()); }

  inline void set_xct_id(xct::XctId new_xct_id) {
    if (log_length_ >= 16) {
      xct_id_ = new_xct_id;
    } else {
      // So far only log type that omits xct_id is FillerLogType.
      ASSERT_ND(get_type() == kLogCodeFiller);
    }
  }

  friend std::ostream& operator<<(std::ostream& o, const LogHeader& v);
};

#define LOG_TYPE_NO_CONSTRUCT(clazz) \
  clazz() CXX11_FUNC_DELETE;\
  clazz(const clazz &other) CXX11_FUNC_DELETE;\
  ~clazz() CXX11_FUNC_DELETE;

struct BaseLogType {
  LogHeader   header_;
};
STATIC_SIZE_CHECK(sizeof(BaseLogType), 16)


struct EngineLogType : public BaseLogType {
  bool    is_engine_log()     const { return true; }
  bool    is_storage_log()    const { return false; }
  bool    is_record_log()     const { return false; }
  void apply_storage(Engine* /*engine*/, storage::StorageId /*storage_id*/) {
    ASSERT_ND(false);
  }
  void apply_record(
    thread::Thread* /*context*/,
    storage::StorageId /*storage_id*/,
    xct::RwLockableXctId* /*owner_id*/,
    char* /*payload*/) {
    ASSERT_ND(false);
  }
  void assert_valid_generic() const ALWAYS_INLINE {
    ASSERT_ND(header_.is_valid_type());
    ASSERT_ND(header_.log_length_ != 0);
    ASSERT_ND(header_.log_length_ % 8 == 0);  // must be 8 byte aligned
    ASSERT_ND(header_.storage_id_ == 0);
  }
};
STATIC_SIZE_CHECK(sizeof(EngineLogType), 16)


struct StorageLogType : public BaseLogType {
  bool    is_engine_log()     const { return false; }
  bool    is_storage_log()    const { return true; }
  bool    is_record_log()     const { return false; }
  void apply_engine(thread::Thread* /*context*/) {
    ASSERT_ND(false);
  }
  void apply_record(
    thread::Thread* /*context*/,
    storage::StorageId /*storage_id*/,
    xct::RwLockableXctId* /*owner_id*/,
    char* /*payload*/) {
    ASSERT_ND(false);
  }
  void assert_valid_generic() ALWAYS_INLINE {
    ASSERT_ND(header_.is_valid_type());
    ASSERT_ND(header_.log_length_ != 0);
    ASSERT_ND(header_.log_length_ % 8 == 0);  // must be 8 byte aligned
    ASSERT_ND(header_.storage_id_ > 0);
  }
};
STATIC_SIZE_CHECK(sizeof(StorageLogType), 16)


struct RecordLogType : public BaseLogType {
  bool    is_engine_log()     const { return false; }
  bool    is_storage_log()    const { return false; }
  bool    is_record_log()     const { return true; }
  void apply_engine(thread::Thread* /*context*/) {
    ASSERT_ND(false);
  }
  void apply_storage(Engine* /*engine*/, storage::StorageId /*storage_id*/) {
    ASSERT_ND(false);
  }
  void assert_valid_generic() const ALWAYS_INLINE {
    ASSERT_ND(header_.is_valid_type());
    ASSERT_ND(header_.log_length_ != 0);
    ASSERT_ND(header_.log_length_ % 8 == 0);  // must be 8 byte aligned
    ASSERT_ND(header_.storage_id_ > 0);
  }
};
STATIC_SIZE_CHECK(sizeof(RecordLogType), 16)


struct FillerLogType : public BaseLogType {
  enum Constants {
    kLogWriteUnitSize = 1 << 12,
  };

  LOG_TYPE_NO_CONSTRUCT(FillerLogType)

  // this is a special log type where it is valid and skipped in every context
  bool    is_engine_log()     const { return true; }
  bool    is_storage_log()    const { return true; }
  bool    is_record_log()     const { return true; }
  void    apply_engine(thread::Thread* /*context*/) {}
  void    apply_storage(Engine* /*engine*/, storage::StorageId /*storage_id*/) {}
  void    apply_record(
    thread::Thread* /*context*/,
    storage::StorageId /*storage_id*/,
    xct::RwLockableXctId* /*owner_id*/,
    char* /*payload*/) {}

  void    populate(uint64_t size);

  void    assert_valid() const ALWAYS_INLINE {
    ASSERT_ND(header_.get_type() == kLogCodeFiller);
    ASSERT_ND(header_.log_length_ >= 8);  // note: it CAN be only 8, not 16 (sizeof FillerLogType)
    ASSERT_ND(header_.log_length_ % 8 == 0);
    ASSERT_ND(header_.storage_id_ == 0);
  }

  friend std::ostream& operator<<(std::ostream& o, const FillerLogType &v);
};
STATIC_SIZE_CHECK(sizeof(FillerLogType), 16)
// NOTE: As a class, it's 16 bytes. However, it might be only 8 bytes in actual log.
// In that case, xct_id is omitted.


struct EpochMarkerLogType : public EngineLogType {
  LOG_TYPE_NO_CONSTRUCT(EpochMarkerLogType)

  void    apply_engine(thread::Thread* context);

  Epoch   old_epoch_;  // +4  => 20
  Epoch   new_epoch_;  // +4  => 24

  uint8_t     logger_numa_node_;  // +1 => 25
  uint8_t     logger_in_node_ordinal_;  // +1 => 26
  uint16_t    logger_id_;  // +2 => 28

  uint32_t    log_file_ordinal_;  // +4 => 32

  uint64_t    log_file_offset_;  // +8 => 40

  void    populate(Epoch old_epoch, Epoch new_epoch,
           uint8_t logger_numa_node, uint8_t logger_in_node_ordinal,
           uint16_t logger_id, uint32_t log_file_ordinal, uint64_t log_file_offset);
  void    assert_valid() const ALWAYS_INLINE { assert_valid_generic(); }

  friend std::ostream& operator<<(std::ostream& o, const EpochMarkerLogType &v);
};
STATIC_SIZE_CHECK(sizeof(EpochMarkerLogType), 40)

}  // namespace log
}  // namespace foedus
#endif  // FOEDUS_LOG_COMMON_LOG_TYPES_HPP_