tdb_base.h

Go to the documentation of this file.

#ifndef TDB_BASE_H
#define TDB_BASE_H
 
#include "config.h"
 
// Always prefer the C++ new/delete expressions rather than using malloc except
// when one needs aligned_alloc(3) because aligned new is not available until
// C++17.
#ifdef USE_JEMALLOC
#   include <jemalloc/jemalloc.h>
#else
#   include <cstdlib>
 
using std::free;
 
// aligned_alloc is not in C++11 but should be available as long as
// _ISOC11_SOURCE is defined
#ifndef _ISOC11_SOURCE
#if __cplusplus >= 201703L
using std::aligned_alloc;
#else // __cplusplus < 201703L
#error "need a working aligned_alloc(3)"
#endif //  __cplusplus
#endif // _ISOC11_SOURCE
 
#endif // USE_JEMALLOC
 
#include <memory>
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstring>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <new>
#include <string>
#include <vector>
#include <utility>
#include <functional>
#include <limits>
 
#include "base/atomics.h"
 
#include <absl/base/macros.h>
#include <absl/memory/memory.h>
#include <absl/strings/string_view.h>
 
using std::size_t;
using std::ptrdiff_t;
using std::uint64_t;
using std::int64_t;
using std::uint32_t;
using std::int32_t;
using std::uint16_t;
using std::int16_t;
using std::int8_t;
using std::uint8_t;
using std::uintptr_t;
using std::intptr_t;
 
using std::static_pointer_cast;
using std::dynamic_pointer_cast;
using std::const_pointer_cast;
#if __cplusplus >= 201703L
// this is available starting from C++17
using std::reinterpret_pointer_cast;
#else
template<class T, class U>
static inline std::shared_ptr<T>
reinterpret_pointer_cast(const std::shared_ptr<U>& p) {
    return std::shared_ptr<T>(p, reinterpret_cast<T*>(p.get()));
}
#endif
 
namespace AlignedAllocImpl {
struct FreeMem {
    void operator()(void *x) {
        free(x);
    }
};
}   // AlignedAllocImpl
 
typedef std::unique_ptr<void, AlignedAllocImpl::FreeMem>
        unique_malloced_ptr;
 
inline unique_malloced_ptr
unique_aligned_alloc(size_t alignment, size_t size) {
    return unique_malloced_ptr(aligned_alloc(alignment, size));
}
 
inline unique_malloced_ptr
wrap_malloc(void *ptr) {
    return unique_malloced_ptr(ptr);
}
 
inline unique_malloced_ptr
unique_malloc(size_t size) {
    return unique_malloced_ptr(malloc(size));
}
 
namespace AlignedAllocImpl {
 
template<size_t alignment, class T>
struct aligned_allocator {
    typedef T value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
 
    static T*
    allocate(size_t n) {
        return (T*) aligned_alloc(alignment, n * sizeof(T));
    }
 
    static void
    deallocate(T *p, size_t) {
        free(p);
    }
 
    constexpr bool
    operator==(const aligned_allocator&) {
        return true;
    }
 
    constexpr bool
    operator!=(const aligned_allocator&) {
        return false;
    }
 
    typedef std::true_type is_always_equal;
 
    template<class U>
    struct rebind {
        typedef aligned_allocator<alignment, U> other;
    };
};
 
 
}   // AlignedAllocImpl
 
using maxaligned_char_buf =
    std::vector<char, AlignedAllocImpl::aligned_allocator<8, char>>;
 
 
constexpr const size_t CACHELINE_SIZE = L1_CACHELINE_SIZE;
constexpr const size_t PAGE_SIZE = CONFIG_PAGE_SIZE;
 
 
#include "base/logging.h"
#include "utils/misc.h"
 
// ASSERT(condition [, <fmtstring> [, <args>]...])
//
// Assertion is enabled when NDEBUG is not defined.  Here we do not use the
// standard C assert() macro. Instead, it throws a fatal error so that our
// exception handler can catch it and provide better insight rather than an
// abort() call.
#if (defined(TDB_IN_TEST) && !defined(NDEBUG))
// In-test asserts shouldn't add the file location in the log, as they are
// always included in the log message.
#define ASSERT(...) \
    do { \
        bool __cond = (CAR(__VA_ARGS__)); \
        if (!__cond) { \
            LOG(::taco::kFatal, \
                    "assertion \"" \
                    STRINGIFY(CAR(__VA_ARGS__)) \
                    "\" failed" \
                    IF_NONEMPTY_COMMA(CADR(__VA_ARGS__), ": ") \
                    CDR(__VA_ARGS__) \
                    ); \
        } \
    } while (0)
#elif (!defined(TDB_IN_TEST) && !defined(NDEBUG))
// Non-test assert failure should be a fatal error and needs to log a file
// location for debugging
#define ASSERT(...) \
    do { \
        bool __cond = (CAR(__VA_ARGS__)); \
        if (!__cond) { \
            LOG(::taco::kFatal, "%s:" STRINGIFY(__LINE__) \
                    ": assertion \"" \
                    STRINGIFY(CAR(__VA_ARGS__)) \
                    "\" failed" \
                    IF_NONEMPTY(CADR(__VA_ARGS__), ": "), \
                    ::taco::StripSourcePath(__FILE__) \
                    IF_NONEMPTY_COMMA(CADR(__VA_ARGS__), ) \
                    CDR(__VA_ARGS__) \
                    ); \
        } \
    } while (0)
#else   // assert disabled
#define ASSERT(...)
#endif
 
namespace taco {
 
typedef uint32_t    Oid;
typedef int16_t     FieldOffset;
typedef int16_t     FieldId;
typedef uint32_t    PageNumber;
typedef uint64_t    BufferId;
 
typedef uint32_t    FileId;
typedef uint16_t    SlotId;
 
constexpr Oid InvalidOid = 0;
constexpr FieldId InvalidFieldId = 0x7fff;
constexpr FieldId MaxNumRegularFieldId = 0x7fff;
constexpr int PageNumberBits = 32;
constexpr int FieldOffsetBits = logn_ceil(PAGE_SIZE);
static_assert(FieldOffsetBits <= 15, "page size cannot be larger than 2^15");
constexpr FieldOffset MaxFieldOffset = (1 << FieldOffsetBits) - 1;
 
constexpr PageNumber INVALID_PID = 0;
 
constexpr PageNumber RESERVED_PID = ~(PageNumber) 0;
 
constexpr PageNumber MaxPageNumber =
    (RESERVED_PID == ((((uint64_t) 1) << PageNumberBits) - 1))
        ? (RESERVED_PID - 2) : ((((uint64_t) 1) << PageNumberBits) - 1);
 
constexpr SlotId INVALID_SID = 0;
 
constexpr SlotId MinSlotId = 1;
 
constexpr SlotId MaxSlotId = (~(SlotId) 0) - 1;
 
constexpr BufferId INVALID_BUFID = ~(BufferId) 0;
 
#define FIELDOFFSET_FORMAT "%hd"
#define FIELDID_FORMAT "%hd"
#define OID_FORMAT "%u"
#define FILEID_FORMAT "%u"
#define PAGENUMBER_FORMAT "0x%08X"
#define SLOTID_FORMAT "%hu"
#define BUFFERID_FORMAT "%lu"
 
constexpr Oid MaxOid = std::numeric_limits<Oid>::max() - 1;
 
typedef uint8_t IdxType;
 
typedef uint8_t OpType;
 
typedef uint8_t AggType;
 
template<class T>
constexpr T
TYPEALIGN(uint64_t ALIGNVAL, T LEN) {
    return (((uint64_t) (LEN) + ((ALIGNVAL) - 1)) & ~((uint64_t) ((ALIGNVAL) - 1)));
}
 
#define SHORTALIGN(LEN)            TYPEALIGN(2, (LEN))
#define INTALIGN(LEN)            TYPEALIGN(4, (LEN))
#define LONGALIGN(LEN)            TYPEALIGN(8, (LEN))
#define DOUBLEALIGN(LEN)        TYPEALIGN(8, (LEN))
#define MAXALIGN(LEN)            TYPEALIGN(8, (LEN))
#define CACHELINEALIGN(LEN)        TYPEALIGN(CACHELINE_SIZE, (LEN))
#define MAXALIGN_OF             8
 
template<class T>
constexpr T
TYPEALIGN_DOWN(uint64_t ALIGNVAL, T LEN) {
    return (((uint64_t) (LEN)) & ~((uint64_t) ((ALIGNVAL) - 1)));
}
 
#define SHORTALIGN_DOWN(LEN)    TYPEALIGN_DOWN(2, (LEN))
#define INTALIGN_DOWN(LEN)        TYPEALIGN_DOWN(4, (LEN))
#define LONGALIGN_DOWN(LEN)        TYPEALIGN_DOWN(8, (LEN))
#define DOUBLEALIGN_DOWN(LEN)    TYPEALIGN_DOWN(8, (LEN))
#define MAXALIGN_DOWN(LEN)        TYPEALIGN_DOWN(8, (LEN))
#define BUFFERALIGN_DOWN(LEN)    TYPEALIGN_DOWN(CACHELINE_SIZE, (LEN))
 
template<class T, class U>
bool
AddWithCheck(T &left, U right) {
    if ((left > 0 && (T) right > std::numeric_limits<T>::max() - left) ||
        (left < 0 && (T) right < left - std::numeric_limits<T>::min())) {
        return false;
    }
    left += (T) right;
    return true;
}
 
#define RETURN_IF(...) \
    do { \
        if ((CAR(__VA_ARGS__))) { \
            return CDR(__VA_ARGS__); \
        } \
    } while(0)
 
}       // namespace taco
 
#define FLEXIBLE_ARRAY_MEMBER -1
 
#include "base/datum.h"
#include "base/fmgr.h"
 
#ifdef ABSL_USES_STD_STRING_VIEW
#define cast_as_string(t) t
#else
 
template<class T>
typename std::enable_if<!std::is_same<typename std::decay<T>::type,
                                      absl::string_view>::value,
                        T&&>::type
cast_as_string(T&& t) {
    return std::forward<T>(t);
}
 
template<class T>
typename std::enable_if<std::is_same<typename std::decay<T>::type,
                                     absl::string_view>::value,
                        std::string>::type
cast_as_string(T t) {
    return std::string(t.data(), t.size());
}
 
#endif // ABSL_USES_STD_STRING_VIEW
 
#endif  // TDB_BASE_H