assorted_func.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_ASSORTED_ASSORTED_FUNC_HPP_
#define FOEDUS_ASSORTED_ASSORTED_FUNC_HPP_
#include <stdint.h>

#include <iosfwd>
#include <string>
#include <typeinfo>

#include "foedus/assert_nd.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/assorted/uniform_random.hpp"

namespace foedus {
namespace assorted {

template <typename T, uint64_t ALIGNMENT>
inline T align(T value) {
  uint64_t left = (value + ALIGNMENT - 1);
  uint64_t right = -ALIGNMENT;
  uint64_t result = left & right;
  ASSERT_ND(result >= static_cast<uint64_t>(value));
  ASSERT_ND(result % ALIGNMENT == 0);
  ASSERT_ND(result < static_cast<uint64_t>(value) + ALIGNMENT);
  return static_cast<T>(result);
}

template <typename T> inline T align8(T value) { return align<T, 8>(value); }

template <typename T> inline T align16(T value) { return align<T, 16>(value); }

template <typename T> inline T align64(T value) { return align<T, 64>(value); }


int64_t int_div_ceil(int64_t dividee, int64_t dividor);

std::string replace_all(const std::string& target, const std::string& search,
               const std::string& replacement);
std::string replace_all(const std::string& target, const std::string& search,
               int replacement);

std::string os_error();

std::string os_error(int error_number);

std::string get_current_executable_path();

struct Hex {
  template<typename T>
  Hex(T val, int fix_digits = -1) : val_(static_cast<uint64_t>(val)), fix_digits_(fix_digits) {}

  uint64_t    val_;
  int         fix_digits_;
  friend std::ostream& operator<<(std::ostream& o, const Hex& v);
};

struct HexString {
  HexString(const std::string& str, uint32_t max_bytes = 64U)
    : str_(str), max_bytes_(max_bytes) {}

  std::string str_;
  uint32_t    max_bytes_;
  friend std::ostream& operator<<(std::ostream& o, const HexString& v);
};

struct Top {
  Top(const char* data, uint32_t data_len, uint32_t max_bytes = 8)
    : data_(data), data_len_(data_len), max_bytes_(max_bytes) {}

  const char*   data_;
  uint32_t      data_len_;
  uint32_t      max_bytes_;
  friend std::ostream& operator<<(std::ostream& o, const Top& v);
};


void spinlock_yield();

template<uint64_t SIZE1, uint64_t SIZE2>
inline int static_size_check() {
  CXX11_STATIC_ASSERT(SIZE1 == SIZE2,
    "Static Size Check failed. Look for a message like this to see the value of Size1 and "
    "Size2: 'In instantiation of int foedus::assorted::static_size_check() [with long unsigned"
    " int SIZE1 = <size1>ul; long unsigned int SIZE2 = <size2>ul]'");
  return 0;
}

std::string demangle_type_name(const char* mangled_name);

template <typename T>
std::string get_pretty_type_name() {
  return demangle_type_name(typeid(T).name());
}

uint64_t generate_almost_prime_below(uint64_t threshold);

struct SpinlockStat {
  inline SpinlockStat() : spins_(0) {}
  void yield_backoff();

  uint32_t      spins_;
  UniformRandom rnd_;
};

}  // namespace assorted
}  // namespace foedus

#define SPINLOCK_WHILE(x) \
  for (foedus::assorted::SpinlockStat __spins; (x); __spins.yield_backoff())

// Use __COUNTER__ to generate a unique method name
#define STATIC_SIZE_CHECK_CONCAT_DETAIL(x, y) x##y
#define STATIC_SIZE_CHECK_CONCAT(x, y) STATIC_SIZE_CHECK_CONCAT_DETAIL(x, y)
#define STATIC_SIZE_CHECK_METHOD_NAME \
  STATIC_SIZE_CHECK_CONCAT(_dummy_static_size_check, __COUNTER__)
#define STATIC_SIZE_CHECK(desired, actual) \
  inline void STATIC_SIZE_CHECK_METHOD_NAME() { \
    foedus::assorted::static_size_check< desired, actual >();\
  }

#define INSTANTIATE_ALL_INTEGER_TYPES(M) M(int64_t);  \
  M(int32_t); M(int16_t); M(int8_t); M(uint64_t);  \
  M(uint32_t); M(uint16_t); M(uint8_t); 
#define INSTANTIATE_ALL_INTEGER_PLUS_BOOL_TYPES(M) INSTANTIATE_ALL_INTEGER_TYPES(M);\
  M(bool); 
#define INSTANTIATE_ALL_NUMERIC_TYPES(M) INSTANTIATE_ALL_INTEGER_TYPES(M);\
  M(bool); M(float); M(double); 
#define INSTANTIATE_ALL_TYPES(M) INSTANTIATE_ALL_NUMERIC_TYPES(M);\
  M(std::string);  
#endif  // FOEDUS_ASSORTED_ASSORTED_FUNC_HPP_