trace.h

Go to the documentation of this file.

// Copyright 2024 Markus Anders
// This file is part of dejavu 2.0.
// See LICENSE for extended copyright information.
 
#ifndef DEJAVU_TRACE_H
#define DEJAVU_TRACE_H
 
#include <vector>
#include <cassert>
#include <cstdint>
 
namespace dejavu {
    namespace ir {
#define TRACE_MARKER_INDIVIDUALIZE     (INT32_MAX-7)
#define TRACE_MARKER_REFINE_START      (INT32_MAX-2)
#define TRACE_MARKER_REFINE_END        (INT32_MAX-3)
#define TRACE_MARKER_REFINE_CELL_START (INT32_MAX-4)
#define TRACE_MARKER_REFINE_CELL_END   (INT32_MAX-5)
 
        class trace {
        private:
            // the trace
            std::vector<int> data; 
            trace *compare_trace = nullptr; 
            unsigned long hash = 0; 
            // mode
            bool compare = false; 
            bool record  = false; 
            // housekeeping
            // int cell_act_spot      = -1;
            // int cell_old_color     = -1;
            bool assert_cell_act   = false;
            bool assert_refine_act = false;
 
            // comparison variables
            int position = 0;
            bool comp = true;
 
            void inline add_to_hash(int d) {
                unsigned long ho = hash & 0xff00000000000000; // extract high-order 8 bits from hash
                hash    = hash << 8;                    // shift hash left by 5 bits
                hash    = hash ^ (ho >> 56);            // move the highorder 5 bits to the low-order
                hash    = hash ^ d;                     // XOR into hash
            }
 
            void write_compare(int d) {
                d = std::min(INT32_MAX-10,d);
                dej_assert(d != TRACE_MARKER_INDIVIDUALIZE && d != TRACE_MARKER_REFINE_START);
                write_compare_no_limit(d);
                dej_assert(record?static_cast<int>(data.size())==position:true);
            }
 
            void write_compare_no_limit(int d) {
                add_to_hash(d);
                if (record)  data.push_back(d);
                if (compare) comp = comp && (position < ((int) compare_trace->data.size()))
                                    && (compare_trace->data[position] == d);
                ++position;
            }
 
            /*void write_skip_compare(int d) {
                d = std::min(INT32_MAX-10,d);
                dej_assert(d != TRACE_MARKER_INDIVIDUALIZE && d != TRACE_MARKER_REFINE_START);
                if (record) data.push_back(d);
                ++position;
            }*/
 
        public:
 
            trace* get_compare_trace() {
                return compare_trace;
            }
 
            void op_individualize(const int ind_color) {
                dej_assert(ind_color >= 0);
                write_compare_no_limit(TRACE_MARKER_INDIVIDUALIZE);
                write_compare(ind_color);
            }
 
            void op_refine_start() {
                dej_assert(!comp || !assert_refine_act);
                write_compare_no_limit(TRACE_MARKER_REFINE_START);
                assert_refine_act = true;
            }
 
            void op_refine_cell_start(int) {
                dej_assert(!comp || !assert_cell_act);
                write_compare_no_limit(TRACE_MARKER_REFINE_CELL_START);
                //write_compare(color);
                // cell_old_color = color;
                //cell_act_spot = (int) data.size();
                //write_skip_compare(false);
                assert_cell_act = true;
            }
 
            void op_refine_cell_record(int new_color) {
                dej_assert(!comp || assert_cell_act);
                write_compare(new_color);
                //if (new_color != cell_old_color && record) data[cell_act_spot] = true;
            }
 
            void op_additional_info(int d) {
                write_compare(d);
            }
 
            void op_refine_cell_end() {
                dej_assert(!comp || assert_cell_act);
                assert_cell_act = false;
                //
                write_compare_no_limit(TRACE_MARKER_REFINE_CELL_END);
            }
 
            void op_refine_end() {
                dej_assert(!comp || !assert_cell_act);
                dej_assert(assert_refine_act);
                assert_refine_act = false;
                write_compare_no_limit(TRACE_MARKER_REFINE_END);
            }
 
            dej_nodiscard bool blueprint_is_next_cell_active() {
                if (!compare || !comp || position > static_cast<int>(compare_trace->data.size())) return true;
 
                dej_assert(compare_trace);
                size_t read_pt = position;
                dej_assert(compare_trace->data.size() > read_pt);
                for(; read_pt > 0 && compare_trace->data[read_pt] != TRACE_MARKER_REFINE_CELL_START; --read_pt);
                dej_assert(compare_trace->data[read_pt] == TRACE_MARKER_REFINE_CELL_START);
                ++read_pt;
 
                dej_assert(compare_trace->data.size() > read_pt);
                dej_assert((compare_trace->data[read_pt] == false) || (compare_trace->data[read_pt] == true));
                return compare_trace->data[read_pt];
            }
 
            void blueprint_skip_to_next_cell() {
                while (position < static_cast<int>(compare_trace->data.size()) &&
                       compare_trace->data[position] != TRACE_MARKER_REFINE_CELL_END) {
                    dej_assert(compare_trace->data.size() > (size_t) position);
                    ++position;
                }
                ++position;
                assert_cell_act = false;
            }
 
            void rewind_to_individualization() {
                assert_cell_act = false;
                assert_refine_act = false;
                if (record) {
                    int read_pt = std::max((int) data.size() - 1, 0);
                    while (read_pt > 0 && data[read_pt] != TRACE_MARKER_INDIVIDUALIZE) {
                        --read_pt;
                    }
                    data.resize(read_pt);
                    position = read_pt;
                }
                if (compare) {
                    int read_pt = std::max(position - 1, 0);
                    while (read_pt > 0 && compare_trace->data[read_pt] != TRACE_MARKER_INDIVIDUALIZE) {
                        --read_pt;
                    }
                    position = read_pt;
                }
            }
 
            void skip_to_individualization() {
                assert_cell_act = false;
                assert_refine_act = false;
                if (compare) {
                    int read_pt = position - 1;
                    while ((size_t) read_pt < compare_trace->data.size() &&
                            compare_trace->data[read_pt] != TRACE_MARKER_INDIVIDUALIZE) {
                        ++read_pt;
                    }
                    position = read_pt;
                }
            }
 
            void set_compare_trace(trace *new_compare_trace) {
                this->compare_trace = new_compare_trace;
            }
 
            void set_compare(bool new_compare) {
                this->compare = new_compare;
            }
 
            dej_nodiscard unsigned long get_hash() const {
                return hash;
            }
 
            void set_hash(unsigned long new_hash) {
                this->hash = new_hash;
            }
 
            dej_nodiscard bool trace_equal() const {
                return comp;
            }
 
            void reset_trace_equal() {
                comp = true;
            }
            void reset_trace_unequal() {
                comp = false;
            }
 
            void reset() {
                data.clear();
                compare_trace = nullptr;
                position = 0;
                hash = 0;
                dej_assert(record?static_cast<int>(data.size())==position:true);
                reset_trace_equal();
            }
 
            // record to trace
            void set_record(bool new_record) {
                this->record = new_record;
            }
 
            void reserve(const int n) {
                data.reserve(n);
            }
 
            // position the trace
            void set_position(int new_position) {
                assert_cell_act   = false;
                assert_refine_act = false;
                this->position = new_position;
                if(record) data.resize(position);
                dej_assert(record?static_cast<int>(data.size())==position:true);
            }
 
            dej_nodiscard int get_position() const {
                return position;
            }
        };
    }
}
 
 
#endif //DEJAVU_TRACE_H