threadsafe/test/test1.cpp

Go to the documentation of this file.

/*
 * test1.cpp
 * 
 * Copyright (C) 2009,2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Testing for threadsafe collections.
 * Mostly this spins off a lot of threads and lets them contend for the same
 *      threadsafe collections over and over again.  Looking for either
 *      exceptions, deadlocks, or corruption.
 */

// includes --------------------------------------------------------------------
#include <iostream>

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "threadsafe/smart_ptr.h"
#include "threadsafe/threadsafe.h"
#include "threadsafe/threadsafe_counter.h"
#include "threadsafe/threadsafe_map.h"
#include "threadsafe/threadsafe_multimap.h"
#include "threadsafe/threadsafe_queue.h"

typedef threadsafe_multimap<std::string, std::string> multi_string_t;
typedef threadsafe_queue<std::string> tqueue_string_t;


class ATest {
public:
        ATest(void) throw() { }
        virtual ~ATest(void) throw() { }

private:
        long            m_l;
};


class BTest : public ATest {
public:
        ~BTest(void) throw() { }

private:
        long            m_l2;
};


typedef smart_ptr<ATest> ptr_t;

typedef void * (*get_context_fn)(void);
typedef void (*test_routine_t)(void *);
typedef void (*valid_fn)(void *);

struct context_t {
        context_t(void) throw() {
                        ctr = NULL;
                        fn = NULL;
                        ctx = NULL;
                }

        // data fields
        threadsafe_counter *    ctr;    // counter
        test_routine_t          fn;     // function to execute
        void *                  ctx;    // context
};


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static float
getRandom
(
void
)
throw()
{
        return (1.0 * rand()) / RAND_MAX;
}



static void *
getContext1
(
void
)
{
        tqueue_string_t * tqs = new tqueue_string_t;
        ASSERT(tqs, "out of memory");

        return tqs;
}



static void *
getSPtrContext
(
void
)
{
        ptr_t * p = new ptr_t;
        ASSERT(p, "out of memory");
        *p = new BTest;
        ASSERT(*p, "out of memory");
        ASSERT(1 == p->get_ref_count(), "Bad ref count? %ld",
            p->get_ref_count());

        return (void *) p;
}



static void *
getMMctx
(
void
)
{
        multi_string_t * ps = new multi_string_t;
        ASSERT(ps, "out of memory");
        return ps;
}



static void
doTest1
(
IN void * pv
)
{
        
        tqueue_string_t * tqs = (tqueue_string_t *) pv;
        ASSERT(tqs, "null context");

        std::string val;
        float x = getRandom();
        if (x < 0.3) {
                //DPRINTF("pushing...");
                val = "test";
                tqs->push_back(val);
        } else if (x < 0.7) {
                //DPRINTF("popping...");
                tqs->pop_front(val);
        } else {
                //DPRINTF("iterating...");
                tqueue_string_t::iterator_t i;
                tqs->getIterator(i);
                while (tqs->getNextElement(i, val)) {
                }
        }
}



static void
doSPtrTest
(
IN void * pv
)
{
        ptr_t * p = (ptr_t *) pv;
        ASSERT(p, "null context");
        ASSERT(p->get_ref_count() > 0, "Bad ref count!");

        ptr_t newP(*p);
        ASSERT(newP, "should be non-null!");
        ASSERT(newP.get_ref_count() > 1, "should be at least 2! %ld",
            newP.get_ref_count());
}



static void
doMultiTest
(
IN void * pv
)
{
        multi_string_t * ps = (multi_string_t *) pv;
        ASSERT(ps, "null context");

        // iterate over all keys
        multi_string_t::iterator_t i;
        ps->getIterator(i);
        std::string key;
        std::string value;
        while (ps->getNextElement(i, key, value)) {
//              DPRINTF("  '%s' --> '%s'", key.c_str(), value.c_str());
        }

        // iterate over all 'a' keys
//      DPRINTF("Have %d elements with key 'a'", ps->count("a"));
        ps->getIterator("a", i);
        while (ps->getNextElement(i, key, value)) {
//              DPRINTF("  '%s' --> '%s'", key.c_str(), value.c_str());
        }

        // add some keys
        int nAdd = rand() % 10;
        char buffer[2];
        buffer[1] = 0;
        for (int j = 0; j < nAdd; ++j) {
                buffer[0] = 'a' + (rand() % 26);
                ps->insert(buffer, buffer);
        }

        // delete some keys
        buffer[0] = 'a' + (rand() % 26);
        ps->remove(buffer);
}



static void
validateSPtr
(
IN void * pv
)
{
        ptr_t * p = (ptr_t *) pv;
        ASSERT(p, "null context?");

        if (1 != p->get_ref_count()) {
                WAVE_EX(wex);
                wex << "smart pointer test failed ref count!\n";
                wex << "Expected exactly 1 ref count, but found ";
                wex << p->get_ref_count();
        }
        delete p;
}



static void *
threadStartWrapper
(
IN void * pv
)
{
        context_t * ctx = (context_t *) pv;
        ASSERT(ctx, "null context");
        ASSERT(ctx->ctr, "null counter");
        ASSERT(ctx->fn, "null test function");

        // auto increment/decrement counter
        counter_ref cref(ctx->ctr);

        // now loop many times and call test function
        for (int i = 0; i < 100 * 1000; ++i) {
                sleep(0);
                ctx->fn(ctx->ctx);
        }

        // all done!
        return NULL;
}




void
threadLoop
(
IN int nThreads,
IN get_context_fn getContext,
IN test_routine_t fn,
IN valid_fn valid = NULL
)
{
        ASSERT(nThreads > 0, "Bad thread count: %d", nThreads);
        ASSERT(fn, "null thread start function");
        // ASSERT(valid) -- can be null!

        threadsafe_counter c;

        context_t ctx;
        ctx.ctx = getContext();
        ctx.ctr = &c;
        ctx.fn = fn;

        for (int i = 0; i < nThreads; ++i) {
                thread_id_t id;
                createThread(threadStartWrapper, &ctx, id);
        }

        // wait for threads to exit
        sleep(1);
        while (c.getCount()) {
                sleep(1);
        }
        DPRINTF("Done waiting for threads!");

        if (valid) {
                valid(ctx.ctx);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;

        int nThreads = 10;
        if (argc > 1) {
                nThreads = atoi(argv[1]);
        }
        DPRINTF("Using %d threads.", nThreads);
        ASSERT(nThreads > 0, "Bad thread count: %d", nThreads);

        try {
                perf::Timer timer("threadsafe test1 -- overall timer");

                DPRINTF("Testing smart_ptr<T>...");
                threadLoop(nThreads, getSPtrContext, doSPtrTest, validateSPtr);

                DPRINTF("Testing queues...");
                threadLoop(nThreads, getContext1, doTest1);

                DPRINTF("Testing multimap (this takes ~30 seconds)...");
                threadLoop(nThreads, getMMctx, doMultiTest);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                retval = 1;
        }

        perf::dumpTimingSummary(std::cerr);

        // all done
        return retval;
}