test/test_atomic.h

Go to the documentation of this file.

/*
 * (c) Copyright 2008, IBM Corporation.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *  yy-mm-dd  Developer  Defect     Description
 *  --------  ---------  ------     -----------
 *  08-11-01  ganzhi    N/A        Initial implementation
 */
#ifndef TEST_ATOMIC_H_
#define TEST_ATOMIC_H_

#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/TestAssert.h>
#include "baseTest.h"
#include <amino/cstdatomic>
#include <iostream>

using namespace std;


template<class ParaType> 
class AtomicTest :public CppUnit::TestFixture{
    CPPUNIT_TEST_SUITE(AtomicTest);
    CPPUNIT_TEST(testAcqRel);
    CPPUNIT_TEST_SUITE_END();

    public:
    AtomicTest() {
    }

    void setUp() {
    }

    void reset() {
    }

    void tearDown() {
    }

    void testAcqRel();
};

class IntProducer{
    private:
        atomic<bool> * _flag;
        volatile int * _product;
    public:
        IntProducer(atomic<bool> & flag, volatile int & product){
            _flag = &flag;
            _product = &product;
        }

        void operator()(){
            int opCount = TestConfig::getInstance()->getOperationNum();
            for(int i=0;i<opCount;i++){
                // wait unti _flag becomes FALSE
                while(_flag->load(memory_order_acquire))
                {}

                (*_product) = i;

                _flag->store(true, memory_order_release);
            }
        }
};

class IntConsumer{
    private:
        atomic<bool> * _flag;
        volatile int * _product;
    public:
        volatile bool error;

        IntConsumer(atomic<bool> & flag, volatile int & product){
            _flag = &flag;
            _product = &product;

            error = false;
        }

        void operator()(){
            int opCount = TestConfig::getInstance()->getOperationNum();

            for(int i=0;i<opCount;i++){
                // wait until product is ready
                while(!_flag->load(memory_order_acquire))
                {}

                if(*_product != i)
                    error = true;

                _flag->store(false, memory_order_release);
            } 
        }
};

template<typename ParaType> 
void AtomicTest<ParaType>::testAcqRel() {
    /* 
     * false: slot is empty, so producer can create product
     * true: slot is full, so consumer can consume product
     */
    atomic<bool> flag;
    flag = false;
    /* the product */
    volatile int product;
    product = 0;

    IntProducer producer(flag, product);
    IntConsumer consumer(flag, product);

    Thread thread1(producer);
    Thread thread2(consumer);

    thread1.join();
    thread2.join();

    CPPUNIT_ASSERT(!consumer.error);
}

template<class ParaType, char const* CLASS_NAME> 
class AtomicNumTest:public CppUnit::TestFixture{
    CPPUNIT_TEST_SUITE(AtomicNumTest);
    CPPUNIT_TEST(testPlusSub);
    CPPUNIT_TEST_SUITE_END();

    private:
        atomic<ParaType> fVar;
    public:
    AtomicNumTest() {
    }

    atomic<ParaType> * getAtomic(){
        return &fVar;
    }

    void setUp() {
        fVar = 0;
    }

    void reset() {
    }

    void tearDown() {
    }

    void testPlusSub();
};

template<class ParaType, char const* CLASS_NAME> 
class ThreadMath : public TestThread<ParaType> {
private:
        atomic<ParaType> * atomic_var;
        AtomicNumTest<ParaType, CLASS_NAME> * test;
        int operationNum;
public:

        ThreadMath(atomic<ParaType> * var, AtomicNumTest<ParaType, CLASS_NAME> * test_case,
                        int nOperation) :
        atomic_var(var), test(test_case), operationNum(nOperation) {
        }

        void* run() {
                for (int i = 0; i< operationNum; ++i) {
            if(i%2 == 0){
                (*atomic_var)++;
                ParaType oldV = atomic_var->load();
                do{
                }while(!atomic_var->compare_swap(oldV, oldV+1)); 
            }
            else{
                (*atomic_var)--;
                ParaType oldV = atomic_var->load();
                do{
                }while(!atomic_var->compare_swap(oldV, oldV-1)); 
            }
                }
                return NULL;
        }
};

template<class ParaType, char const* CLASS_NAME> class MathThreadFactory :
public ThreadFactory<ParaType> {
private:
        atomic<ParaType> * atomic_var;
        AtomicNumTest<ParaType, CLASS_NAME> * test;
public:

        MathThreadFactory(atomic<ParaType> * s, AtomicNumTest<ParaType, CLASS_NAME> * test_case) :
        atomic_var(s), test(test_case) 
    {
    }

        virtual Runnable** createThreads(int threadNum, int elementNum, int operationNum) {
                test->reset();
                atomic_var = test->getAtomic();
                this->inVec.clear();
                this->outVec.clear();

                typedef Runnable* pRunnable;
                pRunnable* threads;
                threads = new pRunnable[threadNum];
                for (int i=0; i<threadNum; i++) {
                        threads[i] = new ThreadMath<ParaType, CLASS_NAME>(atomic_var, test, operationNum);
                }
                return threads;
        }

        virtual void verifyResult(int threadNum, int elementNum) {
                CPPUNIT_ASSERT(atomic_var->load() == 0);
        }
};

template<class ParaType, char const* CLASS_NAME> 
void AtomicNumTest<ParaType, CLASS_NAME>::testPlusSub() {
        MathThreadFactory<ParaType, CLASS_NAME> factory(&fVar, this);
        ThreadRunner::runThreads(&factory, CLASS_NAME, "testPlusSub");
}
#endif /*TEST_ATOMIC_H_*/

---