C:/rwlock/rwlock_test/rwlock_tester.cc

Go to the documentation of this file.

/* ****************************************************************************
 * Owner:               Evgeniy Makeev
 * Created by:  Evgeniy Makeev
 * ****************************************************************************
 */
#include <stdio.h>
#include <errno.h>
#include <iomanip>
#include <time.h>
#ifndef WIN32
#include <sys/time.h>
#endif
#include "rwlock_tester.h"

SyncOStream RWLockTester::stdSyncOStream(&std::cout);

static const unsigned long vthreads=kValidationThreadsNumber, vloops=kValidationLoopsNumber;

void RWLockLoopTest::mark_test_start() 
{
#ifndef WIN32
    struct timeval tv;
    struct timezone tz;
    memset((void*)&tz, 0, sizeof(tz));
    gettimeofday(&tv, &tz);
    total_test_time = (MILLISECONDS)tv.tv_sec * 1000 + (MILLISECONDS)tv.tv_usec / 1000;
//      total_test_time = (MILLISECONDS)clock(); 
#else
        total_test_time = (MILLISECONDS)GetTickCount();
#endif
}

void RWLockLoopTest::mark_test_end() 
{
//    MILLISECONDS end = clock();
//    
//    if(end < total_test_time)
//    {
//        cerr << "!!! clock round up: start=" <<  total_test_time << "; end=" << end << endl;
//        assert(!"clock round up");
//    }

//    cout << "**** start clocks: " << total_test_time << "; End: " << end << endl;
//      total_test_time = (end - total_test_time)/CLOCKS_IN_MILLISEC;
//    cout << "total_test_time: " << total_test_time << endl;
//    cout << "CLOCKS_IN_MILLISEC: " << CLOCKS_IN_MILLISEC << endl;
#ifndef WIN32
    struct timeval tv;
    struct timezone tz;
    memset((void*)&tz, 0, sizeof(tz));    
    gettimeofday(&tv, &tz);
    total_test_time = (MILLISECONDS)tv.tv_sec * 1000 + (MILLISECONDS)tv.tv_usec / 1000 - total_test_time;   
#else
        total_test_time = (MILLISECONDS)GetTickCount() - total_test_time;
#endif
}

volatile void RWLockLoopTest::run(int loops, int rwratio)
{
        if(atomic_inc_return(&run_count) & 1)   
                run_rw(loops, rwratio);
        else                    
                run_wr(loops, rwratio);
}

volatile void RWLockLoopTest::run_rw(int loops, int rwratio)
{
        MILLISECONDS rthread_time = read_test_loop(loops*rwratio);
        MILLISECONDS wthread_time = write_test_loop(loops);

        cslock();
        read_thread_time += rthread_time;
        write_thread_time += wthread_time;
        total_read_thread_time += rthread_time;
        total_write_thread_time += wthread_time;
        csunlock();
}

volatile void RWLockLoopTest::run_wr(int loops, int rwratio)
{
        MILLISECONDS wthread_time = write_test_loop(loops*rwratio);
        MILLISECONDS rthread_time = read_test_loop(loops);

        cslock();
        read_thread_time += rthread_time;
        write_thread_time += wthread_time;
        total_read_thread_time += rthread_time;
        total_write_thread_time += wthread_time;
        csunlock();
}

volatile void RWLockLoopTest::run_r(int loops, int)
{
        MILLISECONDS rthread_time = read_test_loop(loops);

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

volatile void RWLockLoopTest::run_w(int loops, int)
{
        MILLISECONDS wthread_time = write_test_loop(loops);

        cslock();
        write_thread_time += wthread_time;
        total_write_thread_time += wthread_time;
        csunlock();
}

void RWLockLoopTest::print_thread_times(void)
{
        out.lock();
        out << "\tRead thread time=" 
                << (unsigned long)get_read_thread_time() << " milliseconds."
                << "\n\tWrite thread time=" 
                << (unsigned long)get_write_thread_time() << " milliseconds."
                << "\n\tTotal thread time=" 
                << (unsigned long)(get_write_thread_time() + get_read_thread_time()) << " milliseconds."
                << "\n\tTotal test time=" 
                << (unsigned long)get_total_test_time() << " milliseconds.\n\n";
        out.unlock();
}
void RWLockLoopTest::print_mixed_total(void)
{
        out.lock();
        out << "\tTest thread time=" 
                << (unsigned long)get_read_thread_time() << " milliseconds."
                << "\n\tTotal test time=" 
                << (unsigned long)get_total_test_time() << " milliseconds.\n\n";
        out.unlock();
}

void RWLockTester::validate(void)
{
        SystemThread **thread_objs = new SystemThread * [vthreads];
        SystemThread **thread_objs2 = new SystemThread * [vthreads];
        int t;

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

        out.lock();
                out << "Validating " << curr->name() << ":\n";
                out.unlock();

                current_threads = 0;

        signalStart();
        
                curr->enter_write(); // to put all read threads in a waiting state
                for(t=0; t<vthreads; t++)
                {
                        atomic_inc(&current_threads);
                        thread_objs[t] = new SystemThread(&thread_function_read, (void*)this);
                }
                while(current_read_threads != vthreads) SystemSleep(100);
                if(current_threads != vthreads)
                {
                        out.lock();
                        out << "Failed writer test, need to increase loops/threads number.\n";
                        out.unlock();

            exit(-1001);
                }
                curr->leave_write();
                thread_yield();
                for(t=0; t<vthreads; t++)
                {
                        atomic_inc(&current_threads);
                        thread_objs2[t] = new SystemThread(&thread_function_read, (void*)this);
                }
                curr->enter_write();
                if(current_threads <= 0)
                {
                        out << "Failed writer starvation test.\n";
                }
                else
                {
                        out << "Writer starvation test passed - remaining readers: " << 
                                current_threads << " out of " << vthreads*2 << ".\n";
                }
                curr->leave_write();

                SystemSleep(100);

                for(t=0; t<vthreads; t++) 
                {
                        delete thread_objs[t];
                        delete thread_objs2[t];
                }

                if(current_threads != 0)
                {
                        out.lock();
                        out << "Failed the framework test, current_threads= " << current_threads << "\n";
                        out.unlock();
            exit(-1003);
                }

                curr->enter_read();
                for(t=0; t<vthreads; t++)
                {
                        atomic_inc(&current_threads);
                        thread_objs[t] = new SystemThread(&thread_function_write, (void*)this);
                }
                while(current_write_threads != vthreads) SystemSleep(100);
                if(current_threads != vthreads)
                {
                        out.lock();
                        out << "Failed reader test, need to increase loops/threads number.\n";
                        out.unlock();
                }
                curr->leave_read();
                thread_yield();
                for(t=0; t<vthreads; t++)
                {
                        atomic_inc(&current_threads);
                        thread_objs2[t] = new SystemThread(&thread_function_write, (void*)this);
                }

                curr->enter_read();
                if(current_threads <= 0)
                {
                        out << "Failed reader starvation test.\n";
                }
                else
                {
                        out << "Reader starvation test passed - remaining writers: " << 
                                current_threads << " out of " << vthreads*2 << ".\n";
                }
                curr->leave_read();
                SystemSleep(100);
                for(t=0; t<vthreads; t++) 
                {
                        delete thread_objs[t];
                        delete thread_objs2[t];
                }
                if(current_threads != 0)
                {
                        out.lock();
                        out << "Failed the framework test 2, current_threads= " << current_threads << "\n";
                        out.unlock();
            exit(-1013);
                }
        }
        delete [] thread_objs;
        delete [] thread_objs2;
}

void RWLockTester::run_test(int threads_num, int loops, RWLockLoopTestRunFunction testf, int rwratio)
{
        int t;
        SystemThread **thread_objs = new SystemThread * [threads_num];
        set_tests(threads_num, loops, rwratio, testf);

        out.lock();
        out << "\n" << threads << " thread test.\n";
        out.unlock();

        for(std::vector<RWLockLoopTest *>::iterator i=lock_tests.begin(); i != lock_tests.end(); i++)
        {
                curr = *i;
                out.lock();
                out << "    " << curr->name() << ":\n";
                out.unlock();
                current_threads = 0;
                
                clearStartFlag();
        
                for(t=0; t<threads_num; t++)
                {
                        atomic_inc(&current_threads);
                        thread_objs[t] = new SystemThread(&thread_function, (void*)this);
             thread_yield();
                }
                                
                while(current_threads > current_active_threads) thread_yield();

        SystemSleep(2000);
        
                curr->clear_thread_times();
                curr->mark_test_start();
        
                signalStart();

                while(current_threads > 0) thread_yield();

                curr->mark_test_end();

                for(t=0; t<threads_num; t++) 
                {
                        thread_objs[t]->join();
                        delete thread_objs[t];
                        thread_objs[t] = NULL;
            thread_yield();
                }

                if(testfptr == &RWLockLoopTest::run_mixed) 
                        curr->print_mixed_total();
                else 
                        curr->print_thread_times();
        }
        delete [] thread_objs;
}

void * RWLockTester::thread_function_read(void *ptr)
{
        RWLockTester *thisPtr = (RWLockTester *)ptr;
        atomic_inc(&thisPtr->current_active_threads);
        atomic_inc(&thisPtr->current_read_threads);

    thisPtr->waitForStart();
    
        thisPtr->curr->read_test_loop(vloops);

        atomic_dec(&thisPtr->current_read_threads);
        atomic_dec(&thisPtr->current_active_threads);
        atomic_dec(&thisPtr->current_threads);
        return NULL;
}

void * RWLockTester::thread_function_write(void *ptr)
{
        RWLockTester *thisPtr = (RWLockTester *)ptr;
        atomic_inc(&thisPtr->current_active_threads);
        atomic_inc(&thisPtr->current_write_threads);

    thisPtr->waitForStart();
    
        thisPtr->curr->write_test_loop(vloops);

        atomic_dec(&thisPtr->current_write_threads);
        atomic_dec(&thisPtr->current_active_threads);
        atomic_dec(&thisPtr->current_threads);
        return NULL;
}

void * RWLockTester::thread_function(void *ptr)
{
        RWLockTester *thisPtr = (RWLockTester *)ptr;
        atomic_inc(&thisPtr->current_active_threads);
    
    thisPtr->waitForStart();
    
        (thisPtr->curr->*thisPtr->testfptr)(thisPtr->repeat, thisPtr->rw_ratio);

        atomic_dec(&thisPtr->current_active_threads);

        atomic_dec(&thisPtr->current_threads);
        return NULL;
}

void RWLockTester::clear_summary(void)
{
        for(std::vector<RWLockLoopTest *>::iterator i=lock_tests.begin(); i != lock_tests.end(); i++)
                (*i)->clear_total_thread_time();
}

void RWLockTester::print_summary(void)
{
        for(std::vector<RWLockLoopTest *>::iterator i=lock_tests.begin(); i != lock_tests.end(); i++)
        {
                RWLockLoopTest *ct = *i;
                out << "\nTest Summary for " << ct->name() 
                        << ":\n\tTotal read thread time=" 
                        << (unsigned long)ct->get_total_read_thread_time() 
                        << "\n\tTotal write thread time=" 
                        << (unsigned long)ct->get_total_write_thread_time() 
                        << "\n\tTotal R/W thread time="
                        << (unsigned long)(ct->get_total_read_thread_time() + ct->get_total_write_thread_time()) << "\n";
        }
}

void GraphData::init(const RWLockTester &tester, const int *th_counts, size_t thread_count_len)
{
        threads.clear();
        threads.insert(threads.begin(),th_counts, th_counts+thread_count_len);
        for(std::vector<RWLockLoopTest *>::const_iterator i=tester.begin(); i!=tester.end(); i++)
        {
                size_t last = lock_info.size();
                lock_info.resize(last+1);
                lock_info[last].clear();
                lock_info[last].name = (*i)->name();
                lock_info[last].resize(thread_count_len);
        }
}

int GraphData::add_results(const RWLockTester &tester, size_t thread_count_num)
{
        for(size_t indx=0; indx<tester.size(); indx++)
        {
                lock_info[indx].read[thread_count_num] = tester[indx]->get_read_thread_time();
                lock_info[indx].write[thread_count_num] = tester[indx]->get_write_thread_time();
                lock_info[indx].total[thread_count_num] = tester[indx]->get_total_test_time();
        }
        return 0;
}

/*
int GraphData::print_read(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)curr->read[ii]);
                fprintf(f, "\n");
        }
        fclose(f);
        return 0;
}

int GraphData::print_write(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)curr->write[ii]);
                fprintf(f, "\n");
        }
        fclose(f);
        return 0;
}

int GraphData::print_summary(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)curr->write[ii] + curr->read[ii]);
                fprintf(f, "\n");
        }
        fclose(f);
        return 0;
}

int GraphData::print_total_time(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)curr->total[ii]);
                fprintf(f, "\n");
        }
        fclose(f);
        return 0;
}

*/

---