tpcb_env.h

Go to the documentation of this file.

/* -*- mode:C++; c-basic-offset:4 -*-
     Shore-kits -- Benchmark implementations for Shore-MT

                       Copyright (c) 2007-2009
      Data Intensive Applications and Systems Labaratory (DIAS)
               Ecole Polytechnique Federale de Lausanne

                         All Rights Reserved.

   Permission to use, copy, modify and distribute this software and
   its documentation is hereby granted, provided that both the
   copyright notice and this permission notice appear in all copies of
   the software, derivative works or modified versions, and any
   portions thereof, and that both notices appear in supporting
   documentation.

   This code 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. THE AUTHORS
   DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER
   RESULTING FROM THE USE OF THIS SOFTWARE.
*/

#ifndef __TPCB_ENV_H
#define __TPCB_ENV_H

#include "sm_vas.h"

#include "tpcb_input.h"

#include "shore_env.h"
#include "trx_worker.h"

#include "tpcb_schema_man.h"

#include <map>

using std::map;

namespace tpcb {

/********************************************************************
 *
 *  ShoreTPCBEnv Stats
 *
 *  Shore TPC-B Database transaction statistics
 *
 ********************************************************************/

    struct ShoreTPCBTrxCount {
        uint acct_update;

        uint populate_db;

        uint mbench_insert_only;

        uint mbench_delete_only;

        uint mbench_probe_only;

        uint mbench_insert_delete;

        uint mbench_insert_probe;

        uint mbench_delete_probe;

        uint mbench_mix;

        ShoreTPCBTrxCount& operator+=(ShoreTPCBTrxCount const& rhs) {
            acct_update += rhs.acct_update;

            mbench_insert_only += rhs.mbench_insert_only;
            mbench_delete_only += rhs.mbench_delete_only;
            mbench_probe_only += rhs.mbench_probe_only;
            mbench_insert_delete += rhs.mbench_insert_delete;
            mbench_insert_probe += rhs.mbench_insert_probe;
            mbench_delete_probe += rhs.mbench_delete_probe;
            mbench_mix += rhs.mbench_mix;

            return (*this);
        }

        ShoreTPCBTrxCount& operator-=(ShoreTPCBTrxCount const& rhs) {
            acct_update -= rhs.acct_update;

            mbench_insert_only -= rhs.mbench_insert_only;
            mbench_delete_only -= rhs.mbench_delete_only;
            mbench_probe_only -= rhs.mbench_probe_only;
            mbench_insert_delete -= rhs.mbench_insert_delete;
            mbench_insert_probe -= rhs.mbench_insert_probe;
            mbench_delete_probe -= rhs.mbench_delete_probe;
            mbench_mix -= rhs.mbench_mix;

            return (*this);
        }

        uint total() const {
            return (acct_update +
                    mbench_insert_only + mbench_delete_only + mbench_probe_only +
                    mbench_insert_delete + mbench_insert_probe + mbench_delete_probe + mbench_mix);
        }
    }; // EOF: ShoreTPCBTrxCount


    struct ShoreTPCBTrxStats {
        ShoreTPCBTrxCount attempted;

        ShoreTPCBTrxCount failed;

        ShoreTPCBTrxCount deadlocked;

        ShoreTPCBTrxStats& operator+=(ShoreTPCBTrxStats const& other) {
            attempted += other.attempted;
            failed += other.failed;
            deadlocked += other.deadlocked;
            return (*this);
        }

        ShoreTPCBTrxStats& operator-=(ShoreTPCBTrxStats const& other) {
            attempted -= other.attempted;
            failed -= other.failed;
            deadlocked -= other.deadlocked;
            return (*this);
        }
    }; // EOF: ShoreTPCBTrxStats



/********************************************************************
 *
 *  ShoreTPCBEnv
 *
 *  Shore TPC-B Database.
 *
 ********************************************************************/

    class ShoreTPCBEnv : public ShoreEnv {
    public:

        typedef std::map<pthread_t, ShoreTPCBTrxStats*> statmap_t;

        class table_builder_t;
class table_creator_t;
class fid_loader_t;

    public:

        ShoreTPCBEnv(boost::program_options::variables_map vm);

        virtual ~ShoreTPCBEnv();


        // DB INTERFACE

        virtual int set(envVarMap* /* vars */) {
            return (0); /* do nothing */ };

        virtual int open() {
            return (0); /* do nothing */ };

        virtual int pause() {
            return (0); /* do nothing */ };

        virtual int resume() {
            return (0); /* do nothing */ };

        virtual w_rc_t newrun() {
            return (RCOK); /* do nothing */ };

        virtual int post_init();

        virtual w_rc_t load_schema();

        virtual w_rc_t load_and_register_fids();

        virtual int conf();

        virtual int start();

        virtual int stop();

        virtual int info() const;

        virtual int statistics();

        int dump();

        virtual void print_throughput(const double iQueriedSF,
                                      const int iSpread,
                                      const int iNumOfThreads,
                                      const double delay);


        // Public methods //

        // --- operations over tables --- //
        w_rc_t create_tables();

        w_rc_t load_data();

        w_rc_t warmup();

        w_rc_t check_consistency();

        // TPCB Tables
        branch_man_impl* branch_man;

        teller_man_impl* teller_man;

        account_man_impl* account_man;

        history_man_impl* history_man;

        // --- kit baseline trxs --- //

        w_rc_t run_one_xct(Request* prequest);

        // Transactions
        DECLARE_TRX(acct_update);

        // Microbenchmarks
        DECLARE_TRX(mbench_insert_only);

        DECLARE_TRX(mbench_delete_only);

        DECLARE_TRX(mbench_probe_only);

        DECLARE_TRX(mbench_insert_delete);

        DECLARE_TRX(mbench_insert_probe);

        DECLARE_TRX(mbench_delete_probe);

        DECLARE_TRX(mbench_mix);

        // Database population
        DECLARE_TRX(populate_db);

        // for thread-local stats
        virtual void env_thread_init();

        virtual void env_thread_fini();

        // stat map
        statmap_t _statmap;

        // snapshot taken at the beginning of each experiment
        ShoreTPCBTrxStats _last_stats;

        virtual void reset_stats();

        ShoreTPCBTrxStats _get_stats();

        // set load imbalance and time to apply it
        void set_skew(int area, int load, int start_imbalance, int skew_type, bool shifting);

        void start_load_imbalance();

        void reset_skew();

        //print the current tables into files
        w_rc_t db_print(int lines);

        //fetch the pages of the current tables and their indexes into the buffer pool
        w_rc_t db_fetch();
    }; // EOF ShoreTPCBEnv


}; // namespace

#endif // __TPCB_ENV_H