C:/rwlock/rwlock_test/rwlock_tester.h

Go to the documentation of this file.

/* ****************************************************************************
 * Owner:               Evgeniy Makeev
 * Created by:  Evgeniy Makeev
 * ****************************************************************************
 */
#ifndef __RW_LOCK_TESTER_H_Included__
#define __RW_LOCK_TESTER_H_Included__

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include "atomic_util.h"
#include "system_abstraction.h"

using namespace std;

#ifdef WIN32
const unsigned long kValidationThreadsNumber = 40;
const unsigned long kValidationLoopsNumber = 10000;
const unsigned long kPerformanceLoopsNumber = 6400000;
typedef ULONG64  MILLISECONDS;
typedef ULONG64  CLOCK_T;
#else // #ifdef WIN32
const unsigned long kValidationThreadsNumber = 40;
const unsigned long kValidationLoopsNumber = 10000;
const unsigned long kPerformanceLoopsNumber = 64000000;

typedef uint64_t  MILLISECONDS;
typedef uint64_t  CLOCK_T;
#endif // #ifdef WIN32

const unsigned long SLEEP_MSEC = 10;

const CLOCK_T CLOCKS_IN_MILLISEC = CLOCKS_PER_SEC / CLOCK_T(1000);
const int kLoopYields = 1000;

class SyncOStream
{
public:
        SyncOStream(std::ostream * ostr = &cout) : out(ostr) {}

        ~SyncOStream() {}

        void lock(void)         { l.lock(); }
        void unlock(void)       { l.unlock(); }
        std::ostream            *out;
private:
        SystemLock      l;
};

template<class T> SyncOStream & operator<<(SyncOStream &strm, T val)
{
        if(strm.out) 
        {
                (*strm.out) << val;
        }
        return strm;
}

class RWLockLoopTest
{
public:
        enum RWLockLoopTestMode
        {
                RWLockLoopTestRWMode = 0,
                RWLockLoopTestWRMode = 1
        };

        RWLockLoopTest(SyncOStream &so, int loops=kPerformanceLoopsNumber) : 
          out(so), read_thread_time(0), write_thread_time(0),
          total_read_thread_time(0), total_write_thread_time(0), run_count(0) {}

        virtual ~RWLockLoopTest() {}

        volatile void run(int loops, int rwratio=1);
        volatile void run_rw(int loops, int rwratio=1);
        volatile void run_wr(int loops, int rwratio=1);

        volatile void run_r(int loops, int dummy=1);
        volatile void run_w(int loops, int dummy=1);
    
        virtual volatile void run_mixed(int loops, int rwratio=1) = 0;

        virtual volatile MILLISECONDS read_test_loop(int loops) = 0;
        virtual volatile MILLISECONDS write_test_loop(int loops) = 0;

        virtual void enter_read(void) = 0;
        virtual void leave_read(void) = 0;
        virtual void enter_write(void) = 0;
        virtual void leave_write(void) = 0;

        void cslock(void)                                                       { sys_lock.lock(); }
        void csunlock(void)                                                     { sys_lock.unlock(); }

        virtual const char *name() const =0;
        MILLISECONDS get_read_thread_time(void) const           { return read_thread_time; }
        MILLISECONDS get_write_thread_time(void)        const           { return write_thread_time; }
        MILLISECONDS get_total_read_thread_time(void) const     { return total_read_thread_time; }
        MILLISECONDS get_total_write_thread_time(void) const    { return total_write_thread_time; }
        MILLISECONDS get_total_test_time(void) const            { return total_test_time; }

        void mark_test_start();
        void mark_test_end();

        void clear_thread_times(void)                                   { read_thread_time = write_thread_time = 0; run_count = 0;}
        void clear_total_thread_time(void)                              { total_read_thread_time = total_write_thread_time = 0; }

        void print_thread_times(void);
        void print_mixed_total(void);

protected:
    SyncOStream                 &out;
        MILLISECONDS                            read_thread_time;
        MILLISECONDS                            write_thread_time;
        MILLISECONDS                            total_read_thread_time;
        MILLISECONDS                            total_write_thread_time;
        MILLISECONDS                            total_test_time;
        SystemLock                      sys_lock;
        volatile int            run_count;
};

typedef volatile void (RWLockLoopTest::*RWLockLoopTestRunFunction)(int loops, int rwratio);

template<class RWL> class RWLockLoopTestImpl : public RWLockLoopTest
{
public:
        RWLockLoopTestImpl(SyncOStream &so, int loops=kPerformanceLoopsNumber, bool vfy=true) : 
                RWLockLoopTest(so, loops), current_readers(0), current_writers(0), verify(vfy) {}

        volatile MILLISECONDS read_test_loop(int loops);
        volatile MILLISECONDS write_test_loop(int loops);

        volatile void run_mixed(int loops, int rwratio=1);

        virtual void enter_read(void)   {lock.enter_read();}
        virtual void leave_read(void)   {lock.leave_read();}
        virtual void enter_write(void)  {lock.enter_write();}
        virtual void leave_write(void)  {lock.leave_write();}

        const char *name() const { return lock.name(); }
   
private:


        RWL             lock;
        volatile int    current_readers;
        volatile int    current_writers;
    const bool      verify;
};

class RWLockTester
{
public:
        RWLockTester(int loops = 1000000, int threadNum = 1, SyncOStream &os = stdSyncOStream) :
                repeat(loops), threads(threadNum), out(os), 
                current_threads(0), current_active_threads(0), 
                current_read_threads(0), current_write_threads(0)
    {
        assert(CLOCKS_PER_SEC >= CLOCK_T(1000));
        assert(CLOCKS_PER_SEC % CLOCK_T(1000) == 0);
    }

        ~RWLockTester()
        {
                std::vector<RWLockLoopTest *>::iterator i;
                for(i=lock_tests.begin(); i!=lock_tests.end(); i++)
                {
                        delete *i;
                }
        }

        void add_lock_test(RWLockLoopTest *test)        { lock_tests.push_back(test); }
        void validate(void);
        void run_test(  int thread_num=1, 
                                        int loops=kPerformanceLoopsNumber, 
                                        RWLockLoopTestRunFunction tf=&RWLockLoopTest::run, 
                                        int rwratio=1 );

        void set_loops(int loops)                                       { if(loops>0) repeat = loops; }
        void set_threads(int tcount)                            { if(tcount>0) threads = tcount; }
        int get_loops(int loops)                                        { return repeat; }
        int get_threads(int tcount)                                     { return threads; }
        SyncOStream & get_ostream(void)                         { return out; }
        void print_summary(void);
        void clear_summary(void);

        std::vector<RWLockLoopTest *>::const_iterator begin()   const { return lock_tests.begin(); }
        std::vector<RWLockLoopTest *>::const_iterator end()             const { return lock_tests.end(); }
        const RWLockLoopTest * operator[](size_t indx)                  const { return lock_tests[indx]; }
        size_t  size() const { return lock_tests.size(); }

private:    
        static void * thread_function(void *);
        static void * thread_function_read(void *);
        static void * thread_function_write(void *);

        void set_tests(int threads_num, int loops, int rwratio, RWLockLoopTestRunFunction testf)
        {
                threads = threads_num;
                repeat = loops/threads;
                rw_ratio = rwratio;
                testfptr = testf;
        }

    void clearStartFlag(void)   { startFlag = 0; }
    void signalStart(void)      { startFlag = 1; }
    void waitForStart(void)     { while(startFlag == 0) thread_yield(); }
    
    volatile int                            startFlag;
        int                                                                             repeat;
        int                                                                             threads;
        int                                                                             rw_ratio;
        RWLockLoopTestRunFunction                               testfptr;
        RWLockLoopTest *                                                curr;

        std::vector<RWLockLoopTest *>                   lock_tests;

        volatile int                                                    current_threads;
        volatile int                                                    current_active_threads;
        volatile int                                                    current_read_threads;
        volatile int                                                    current_write_threads;
        volatile int                                                    current_rw_threads;
        volatile int                                                    current_wr_threads;
        SyncOStream                                                             &out;

        static SyncOStream                                              stdSyncOStream;
};


struct RWLockGraphData
{
        std::string                     name;
        std::vector<MILLISECONDS> read;
        std::vector<MILLISECONDS> write;
        std::vector<MILLISECONDS> total;
        void clear() { name = ""; read.clear(); write.clear(); total.clear();}
        void resize(size_t new_sz, MILLISECONDS initval=0)
        {
                read.resize(new_sz, initval);
                write.resize(new_sz, initval);
                total.resize(new_sz, initval);
        }
};

class GraphData
{
        std::vector<int>                                threads;
        std::vector<RWLockGraphData>    lock_info;
public:
        GraphData() {}
        void init(const RWLockTester &tester, const int *th_counts, size_t thread_count_len);
        int add_results(const RWLockTester &tester, size_t thread_count_num);

        template <class F> int print(F f, const char *file, const char *title=NULL) const;

        inline static MILLISECONDS get_read(const RWLockGraphData &d, size_t indx)  { return d.read[indx]; }
        inline static MILLISECONDS get_write(const RWLockGraphData &d, size_t indx) { return d.write[indx]; }
        inline static MILLISECONDS get_sum(const RWLockGraphData &d, size_t indx)         { return d.read[indx] + d.write[indx]; }
        inline static MILLISECONDS get_total(const RWLockGraphData &d, size_t indx) { return d.total[indx]; }

        int print_read(const char *file, const char *title=NULL) const;
        int print_write(const char *file, const char *title=NULL) const;
        int print_summary(const char *file, const char *title=NULL) const;
        int print_total_time(const char *file, const char *title=NULL) const;
};

template<class RWL> volatile inline MILLISECONDS RWLockLoopTestImpl<RWL>::read_test_loop(int loops)
{
    int yield_point = loops / kLoopYields;
        CLOCK_T start = CLOCK_T(clock());
        for(int i=0; i<loops; i++)
        {
                lock.enter_read();

        int tmp = current_writers;

        atomic_inc(&current_readers);

       if((i % yield_point) == 0) thread_yield();
        
//        SystemSleep(SLEEP_MSEC);
        
        if(verify && tmp != 0)
                {
                        out.lock();
                        out << "\n\nRW lock " << name() << " current_writers != 0 : " << tmp << "\n";
                        out.unlock();
                        exit(-1);
                }
        
                atomic_dec(&current_readers);

        lock.leave_read();
        }
        CLOCK_T finish = CLOCK_T(clock());
    if(finish < start)
    {
        cerr << "!!! clock round up: start=" << start << "; end=" << finish << "; loops=" << loops << endl;
        assert(!"clock round up");
    }
        return (finish - start)/CLOCKS_IN_MILLISEC;
}

template<class RWL> volatile inline MILLISECONDS RWLockLoopTestImpl<RWL>::write_test_loop(int loops)
{
    int yield_point = loops / kLoopYields;
        CLOCK_T start = CLOCK_T(clock());
        for(int i=0; i<loops; i++)
        {
                lock.enter_write();

        int tmp = current_readers;

        if((i % yield_point) == 0) thread_yield();
        
        if(verify && tmp != 0)
                {
                        out.lock();
                        out << "\n\nRW lock " << name() << " current_readers != 0 : " << tmp << "\n";
                        out.unlock();
                        exit(-12);
                }

        atomic_inc(&current_writers);
        

//        SystemSleep(SLEEP_MSEC);
        
                if(verify && current_writers != 1)
                {
                        out.lock();
                        out << "\n\nRW lock " << name() << " current_writers != 1 : " << current_writers << "\n";
                        out.unlock();
                        exit(-2);
                }

        atomic_dec(&current_writers);
        
                lock.leave_write();
        }
        CLOCK_T finish = CLOCK_T(clock());
    if(finish < start)
    {
        cerr << "!!! clock round up: start=" << start << "; end=" << finish << "; loops=" << loops << endl;
        assert(!"clock round up");
    }
        return (finish - start)/CLOCKS_IN_MILLISEC;
}

template<class RWL> volatile inline void RWLockLoopTestImpl<RWL>::run_mixed(int loops, int rwratio)
{
        MILLISECONDS thread_time;
    int yield_point = loops / kLoopYields;
        CLOCK_T start = CLOCK_T(clock());
        for(int i=0; i<loops; i++)
        {
                for(int j=0; j<rwratio; j++)
                {
                        lock.enter_read();
            
                        int tmp = current_writers;
                        atomic_inc(&current_readers);
                        if(verify && tmp != 0)
                        {
                                out.lock();
                                out << "\n\nRW lock " << name() << " current_writers != 0 : " << tmp << "\n";
                                out.unlock();
                                exit(-1);
                        }
  //          SystemSleep(SLEEP_MSEC);
  //          thread_yield();
                        atomic_dec(&current_readers);
            
                        lock.leave_read();
                }
                lock.enter_write();
                int tmp = current_readers;
                if(verify && tmp != 0)
                {
                        out.lock();
                        out << "\n\nRW lock " << name() << " current_readers != 0 : " << tmp << "\n";
                        out.unlock();
                        exit(-12);
                }
                atomic_inc(&current_writers);
                if(verify && current_writers != 1)
                {
                        out.lock();
                        out << "\n\nRW lock " << name() << " current_writers != 1 : " << current_writers << "\n";
                        out.unlock();
                        exit(-2);
                }

        if((i % yield_point) == 0) thread_yield();

//        SystemSleep(SLEEP_MSEC);
                atomic_dec(&current_writers);
                lock.leave_write();
        }
        CLOCK_T finish = CLOCK_T(clock());

    if(finish < start)
    {
        cerr << "!!! clock round up: start=" << start << "; end=" << finish << "; loops=" << loops << endl;
        assert(!"clock round up");
    }
    
        thread_time = (finish - start)/CLOCKS_IN_MILLISEC;

        cslock();
        read_thread_time += thread_time;
        total_read_thread_time += thread_time;
        csunlock();
}

template <class F> inline int GraphData::print(F binf, const char *file, const char *title) const
{
        FILE *f = fopen(file, "w");
        if(f == NULL) return errno;
        if(title)
                fprintf(f, "# %s\n", title);
        fprintf(f, "%32.32s \t ", "threads:");
        for(std::vector<int>::const_iterator i=threads.begin(); i!=threads.end(); i++)
        {
                fprintf(f, "%16d \t ", *i);
        }
        fprintf(f, "\n");
        for(std::vector<RWLockGraphData>::const_iterator curr=lock_info.begin(); curr!=lock_info.end(); curr++)
        {
                fprintf(f, "\"%-30.30s\" \t ", curr->name.c_str());
                for(size_t ii=0; ii<threads.size(); ii++)
                        fprintf(f, "%16llu \t ", (unsigned long long)binf(*curr, ii));
                fprintf(f, "\n");
        }

        fclose(f);
        return 0;
}
inline int GraphData::print_read(const char *file, const char *title) const
{ return print(get_read, file, title); }

inline int GraphData::print_write(const char *file, const char *title) const
{ return print(get_write, file, title); }

inline int GraphData::print_summary(const char *file, const char *title) const
{ return print(get_sum, file, title); }

inline int GraphData::print_total_time(const char *file, const char *title) const
{ return print(get_total, file, title); }

#endif // __RW_LOCK_TESTER_H_Included__

---