Interpreter.hpp

Go to the documentation of this file.

#pragma once
 
#include "backend/InterpreterOperator.hpp"
#include "backend/StackMachine.hpp"
#include <cerrno>
#include <ctime>
#include <mutable/backend/Backend.hpp>
#include <mutable/catalog/Catalog.hpp>
#include <mutable/IR/Operator.hpp>
#include <mutable/IR/Tuple.hpp>
#include <mutable/util/macro.hpp>
#include <unordered_map>
 
 
namespace m {
 
template<std::size_t N>
struct Block
{
    static constexpr std::size_t CAPACITY = N; 
 
    private:
    template<bool C>
    struct the_iterator
    {
        static constexpr bool IsConst = C;
 
        using block_t = std::conditional_t<IsConst, const Block, Block>;
        using reference = std::conditional_t<IsConst, const Tuple&, Tuple&>;
        using pointer = std::conditional_t<IsConst, const Tuple*, Tuple*>;
 
        private:
        block_t &block_;
        uint64_t mask_;
 
        public:
        the_iterator(block_t &vec, uint64_t mask) : block_(vec), mask_(mask) { }
 
        bool operator==(the_iterator other) {
            M_insist(&this->block_ == &other.block_);
            return this->mask_ == other.mask_;
        }
        bool operator!=(the_iterator other) { return not operator==(other); }
 
        the_iterator & operator++() { mask_ = mask_ & (mask_ - 1UL); /* set lowest 1-bit to 0 */ return *this; }
        the_iterator operator++(int) { the_iterator clone(*this); operator++(); return clone; }
 
        std::size_t index() const { return __builtin_ctzl(mask_); }
 
        reference operator*() const { return block_[index()]; }
        pointer operator->() const { return &block_[index()]; }
    };
 
    public:
    using iterator = the_iterator<false>;
    using const_iterator = the_iterator<true>;
 
    private:
    std::array<Tuple, N> data_; 
    uint64_t mask_ = 0x0; 
    static_assert(N <= 64, "maximum block size exceeded");
    Schema schema_;
 
    public:
    Block() = default;
    Block(const Block&) = delete;
    Block(Block&&) = delete;
 
    Block(Schema schema)
        : schema_(std::move(schema))
    {
        for (auto &t : data_)
            t = Tuple(schema_);
    }
 
    Tuple * data() { return data_.data(); }
    const Tuple * data() const { return data_.data(); }
 
    const Schema & schema() const { return schema_; }
 
    static constexpr std::size_t capacity() { return CAPACITY; }
    std::size_t size() const { return __builtin_popcountl(mask_); }
 
    iterator begin() { return iterator(*this, mask_); }
    iterator end()   { return iterator(*this, 0UL); }
    const_iterator begin() const { return const_iterator(*this, mask_); }
    const_iterator end()   const { return const_iterator(*this, 0UL); }
    const_iterator cbegin() const { return const_iterator(*this, mask_); }
    const_iterator cend()   const { return const_iterator(*this, 0UL); }
 
    iterator at(std::size_t index) {
        M_insist(index < capacity());
        return iterator(*this, mask_ & (-1UL << index));
    }
    const_iterator at(std::size_t index) const { return const_cast<Block>(this)->at(index); }
 
    bool alive(std::size_t index) const {
        M_insist(index < capacity());
        return mask_ & (1UL << index);
    }
 
    bool empty() const { return size() == 0; }
 
    uint64_t mask() const { return mask_; }
    void mask(uint64_t new_mask) { mask_ = new_mask; }
 
    private:
    static constexpr uint64_t AllOnes() { return -1UL >> (8 * sizeof(mask_) - capacity()); }
 
    public:
    Tuple & operator[](std::size_t index) {
        M_insist(index < capacity(), "index out of bounds");
        M_insist(alive(index), "cannot access a dead tuple directly");
        return data_[index];
    }
    const Tuple & operator[](std::size_t index) const { return const_cast<Block*>(this)->operator[](index); }
 
    void fill() { mask_ = AllOnes(); M_insist(size() == capacity()); }
 
    void erase(std::size_t index) {
        M_insist(index < capacity(), "index out of bounds");
        setbit(&mask_, false, index);
    }
    void erase(iterator it) { erase(it.index()); }
    void erase(const_iterator it) { erase(it.index()); }
 
    void clear() {
        mask_ = 0;
        for (auto &t : data_)
            t.clear();
    }
 
M_LCOV_EXCL_START
    friend std::ostream & operator<<(std::ostream &out, const Block<N> &block) {
        out << "Block<" << block.capacity() << "> with " << block.size() << " elements:\n";
        for (std::size_t i = 0; i != block.capacity(); ++i) {
            out << "    " << i << ": ";
            if (block.alive(i))
                out << block[i];
            else
                out << "[dead]";
            out << '\n';
        }
        return out;
    }
 
    void dump(std::ostream &out) const
    {
        out << *this;
        out.flush();
    }
    void dump() const { dump(std::cerr); }
M_LCOV_EXCL_STOP
};
 
struct Interpreter;
 
struct Pipeline : ConstOperatorVisitor
{
    friend struct Interpreter;
 
    private:
    Block<64> block_;
 
    public:
    Pipeline() { }
 
    Pipeline(const Schema &schema)
        : block_(schema)
    {
        block_.mask(1UL); // create one empty tuple in the block
    }
 
    Pipeline(Tuple &&t)
    {
        block_.mask(1UL);
        block_[0] = std::move(t);
    }
 
    void push(const Operator &pipeline_start) { (*this)(pipeline_start); }
 
    void clear() { block_.clear(); }
 
    const Schema & schema() const { return block_.schema(); }
 
    using ConstOperatorVisitor::operator();
#define DECLARE(CLASS) void operator()(Const<CLASS> &op) override;
    M_OPERATOR_LIST(DECLARE)
#undef DECLARE
};
 
struct Interpreter : Backend, ConstOperatorVisitor
{
    public:
    Interpreter() = default;
 
    void register_operators(PhysicalOptimizer &phys_opt) const override { register_interpreter_operators(phys_opt); }
 
    void execute(const MatchBase &plan) const override {
        (*const_cast<Interpreter*>(this))(plan.get_matched_root()); // use former visitor pattern on logical operators
    }
 
    using ConstOperatorVisitor::operator();
#define DECLARE(CLASS) void operator()(Const<CLASS> &op) override;
    M_OPERATOR_LIST(DECLARE)
#undef DECLARE
 
    static Value eval(const ast::Constant &c)
    {
        errno = 0;
        switch (c.tok.type) {
            default: M_unreachable("illegal token");
 
            /* Null */
            case TK_Null:
                M_unreachable("NULL cannot be evaluated to a Value");
 
            /* Integer */
            case TK_OCT_INT:
                return int64_t(strtoll(*c.tok.text, nullptr, 8));
 
            case TK_DEC_INT:
                return int64_t(strtoll(*c.tok.text, nullptr, 10));
 
            case TK_HEX_INT:
                return int64_t(strtoll(*c.tok.text, nullptr, 16));
 
            /* Float */
            case TK_DEC_FLOAT:
                return strtod(*c.tok.text, nullptr);
 
            case TK_HEX_FLOAT:
                M_unreachable("not implemented");
 
            /* String */
            case TK_STRING_LITERAL: {
                std::string str(*c.tok.text);
                auto substr = interpret(str);
                return Catalog::Get().pool(substr.c_str()); // return internalized string by reference
            }
 
            /* Date */
            case TK_DATE: {
                int year, month, day;
                if (3 != sscanf(*c.tok.text, "d'%d-%d-%d'", &year, &month, &day))
                    M_unreachable("invalid date");
                return int32_t(unsigned(year) << 9 | month << 5 | day);
            }
 
            /* Datetime */
            case TK_DATE_TIME: {
                /* Extract date time from string. */
                std::string str_datetime(*c.tok.text);
                std::istringstream ss(str_datetime.substr(2, str_datetime.length() - 3));
 
                /* Parse date time. */
                std::tm tm;
                ss >> get_tm(tm);
                M_insist(not ss.fail(), "failed to parse date time");
 
#if defined(__APPLE__)
                /* Adapt tm_year such that it is non-negative (i.e. >= 1900) since timegm() cannot handle these cases. */
                constexpr long SECONDS_PER_400_YEAR_CYCLE = 12622780800L;
                int cycles = tm.tm_year < 0 ? -tm.tm_year / 400 + 1 : 0;
                tm.tm_year += cycles * 400;
                M_insist(tm.tm_year >= 0);
#endif
 
                /* Convert date time from std::tm to time_t (seconds since epoch). */
                const time_t time = timegm(&tm);
                M_insist(time != -1, "datetime out of bounds");
 
#if defined(__APPLE__)
                return int64_t(time - cycles * SECONDS_PER_400_YEAR_CYCLE);
#else
                return int64_t(time);
#endif
            }
 
            /* Boolean */
            case TK_True:
                return true;
 
            case TK_False:
                return false;
        }
        M_insist(errno == 0, "constant could not be parsed");
    }
 
    static StackMachine compile_load(const Schema &tuple_schema, void *address, const storage::DataLayout &layout,
                                     const Schema &layout_schema, std::size_t row_id = 0, std::size_t tuple_id = 0);
 
    static StackMachine compile_store(const Schema &tuple_schema, void *address, const storage::DataLayout &layout,
                                      const Schema &layout_schema, std::size_t row_id = 0, std::size_t tuple_id = 0);
};
 
}