bench_j1axy_4.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    bench_j1axy_4.h
// Purpose:     Benchmark Join1, a(X,Y), Ver. 4: functions, bitmap dupcheck
// Last Change: 17.09.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 2016-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef BENCH_J1AXY_4_INCLUDED
#define BENCH_J1AXY_4_INCLUDED


//=============================================================================
// This Benchmark is optional:
//=============================================================================

#ifndef VER_INCLUDED
#include "../base/ver.h"
#endif

#if     VER_BENCH_J1AXY_4


//=============================================================================
// Used Types and Macros:
//=============================================================================


#ifndef STR_INCLUDED
#include "../base/str.h"
#endif

#ifndef CHECK_INCLUDED
#include "../base/check.h"
#endif

#ifndef LIST_2_INCLUDED
#include "../rel/list_2.h"
#endif

#ifndef CUR_2_INCLUDED
#include "../rel/cur_2.h"
#endif

#ifndef SET_TT_INCLUDED
#include "../rel/set_tt.h"
#endif

#ifndef REL_N_N_INCLUDED
#include "../rel/rel_n_n.h"
#endif

#ifndef OUT_INCLUDED
#include "out.h"
#endif

#ifndef BENCH_INCLUDED
#include "bench.h"
#endif


//=============================================================================
// Private Constants:
//=============================================================================

//-----------------------------------------------------------------------------
// BENCH_J1AXY_4_MAGIC: Magic number (identifies objects of this class).
//-----------------------------------------------------------------------------

static const long BENCH_J1AXY_4_MAGIC = 0x4A31410AL;    // 'J1A\n'


//=============================================================================
// Benchmark Join1, a(X,Y), Ver. 4: functions, bitmap dupcheck
//=============================================================================

class bench_j1axy_4_c : public bench_c {
        public:


//-----------------------------------------------------------------------------
// Constructor, Destructor:
//-----------------------------------------------------------------------------

        public:

        // Constructor:
        bench_j1axy_4_c();

        // Destructor:
        ~bench_j1axy_4_c();

//-----------------------------------------------------------------------------
// (Object) Methods:
//-----------------------------------------------------------------------------

        // load: Load data file with EDB facts.
        bool load(str_t filename);

        // eval: Do bottom-up evaluation.
        long eval();

        // name: Name of this benchmark.
        str_t name() const {
                return "Join 1, a(X,Y), Ver. 4: functions, bitmap dupcheck";
        }

        // file: List of data files.
        str_t file(int i) const;

        // result: List of correct results of the eval method.
        long result(int i) const;

        // Open cursor (note: load() must be called before this method).
        void open();

        // fetch: Get next tuple, returns false if there is no further tuple.
        inline bool fetch() {
                return result_cursor.fetch();
        }


        // c1: Return value for column 1 of current row in cursor.
        inline int c1() {
                return result_cursor.c1();
        }

        // c2: Return value for column 2 of current row in cursor.
        inline int c2() {
                return result_cursor.c2();
        }

        // error: Did an error occur?
        inline bool error() {
                // EDB relations:
                if(c2_bf.mem_err())
                        return true;
                if(c3_ff.mem_err())
                        return true;
                if(c4_bf.mem_err())
                        return true;
                if(d1_ff.mem_err())
                        return true;
                if(d2_bf.mem_err())
                        return true;

                // Derived b1 tuples (for rule with two IDB lit):
                if(b1_fb.mem_err())
                        return true;

                // Sets for duplicate checks:
                if(b1_bb.mem_err())
                        return true;
                if(b2_bb.mem_err())
                        return true;
                if(c1_bb.mem_err())
                        return true;
                if(a_bb.mem_err())
                        return true;

                // Error with backtrack stacks:
                return Error;
        }

        // close: Close cursor.
        inline void close() {
                result_cursor.close();
        }

//-----------------------------------------------------------------------------
// Copy-constructor and assignment operator are not supported for this class:
//-----------------------------------------------------------------------------

        private:

        // These methods are not implemented:
        bench_j1axy_4_c(const bench_j1axy_4_c& obj);
        bench_j1axy_4_c& operator=(const bench_j1axy_4_c& obj);


//-----------------------------------------------------------------------------
// Debugging Support:
//-----------------------------------------------------------------------------

#if     VER_DEBUG
        // Integrity check:
        public:
        str_t   check() const;

        // Magic number (identifies objects of this class for debugging).
        private:
        long    Magic;          // Must be "BENCH_J1AXY_4_MAGIC".
#endif


#if     VER_DUMP
        public:
        // Display data structure:
        void dump(str_t headline = STR_NULL) const;
#endif

//-----------------------------------------------------------------------------
// Private Object Members:
//-----------------------------------------------------------------------------

        private:

//-----------------------------------------------------------------------------
// Data storage for EDB relations:
//-----------------------------------------------------------------------------

        rel_n_n_c c2_bf;
        list_2_c c3_ff;
        rel_n_n_c c4_bf;
        list_2_c d1_ff;
        rel_n_n_c d2_bf;

//-----------------------------------------------------------------------------
// Relation for storing derived b1 tuples (for rule with two IDB lit):
//-----------------------------------------------------------------------------

        rel_n_n_c b1_fb;
                // Note that columns 1 and 2 are exchanged,
                // because c1 is always input to the mapping, and c2 output.

//-----------------------------------------------------------------------------
// Sets for duplicate checks:
//-----------------------------------------------------------------------------

        set_tt_c b1_bb;
        set_tt_c b2_bb;
        set_tt_c c1_bb;
        set_tt_c a_bb;

//-----------------------------------------------------------------------------
// Result list and cursor:
//-----------------------------------------------------------------------------

        list_2_c result_list;
        cur_2_c  result_cursor;

//-----------------------------------------------------------------------------
// Variable declarations:
//-----------------------------------------------------------------------------

//      int v_2_1;
//      int v_3_2;
//      int v_4_1;
//      int v_4_2;
//      int v_5_1;
//      int v_5_2;

//-----------------------------------------------------------------------------
// Call Depth for Trace Output:
//-----------------------------------------------------------------------------

        OUT_TRACE_DEPTH_DECL;

//-----------------------------------------------------------------------------
// Did an error occur?
//-----------------------------------------------------------------------------

        bool Error;

//-----------------------------------------------------------------------------
// Auxiliary functions:
//-----------------------------------------------------------------------------

        private:

        // start_rule_4: Compute c1 facts for rule with only EDB body literals.
        inline void start_rule_4();

        // derived_c1: Function to call when a c1-tuple was derived.
        inline void derived_c1(int A, int C);

        // derived_b1: Function to call when a b1-tuple was derived.
        inline void derived_b1(int A, int B);

        // start_rule_5: Compute b2 facts for rule with only EDB body literals.
        inline void start_rule_5();

        // derived_b2: Function to call when a b2-tuple was derived.
        inline void derived_b2(int C, int B);

        // derived_a: Function to call when an a-tuple was derived.
        inline void derived_a(int A, int B);

//=============================================================================
// End of Class:
//=============================================================================

};


//=============================================================================
// End of Conditional Compilation of this Test (VER_BENCH_J1AXY_4):
//=============================================================================

#endif


//=============================================================================
// End of Include File:
//=============================================================================

#endif