client.cpp

ICE-3.2 一个开源的中间件

// **********************************************************************
//
// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

#include <Ice/Application.h>
#include <Freeze/Freeze.h>
#include <BenchTypes.h>
#include <cstdlib>

using namespace std;
using namespace Demo;

void
testFailed(const char* expr, const char* file, unsigned int line)
{
    std::cout << "failed!" << std::endl;
    std::cout << file << ':' << line << ": assertion `" << expr << "' failed" << std::endl;
    abort();
}

#define test(ex) ((ex) ? ((void)0) : testFailed(#ex, __FILE__, __LINE__))

class StopWatch
{
public:

    StopWatch()
    {
    }

    void
    start()
    {
        _stopped = false;
        _start = IceUtil::Time::now();
    }

    IceUtil::Time
    stop()
    {
        if(!_stopped)
        {
            _stopped = true;
            _stop = IceUtil::Time::now();
        }

        return _stop - _start;
    }

private:

    bool _stopped;
    IceUtil::Time _start;
    IceUtil::Time _stop;
};

class Generator : public IceUtil::Shared
{
public:

    virtual ~Generator() { }

    virtual int next() = 0;
    virtual string toString() = 0;
};
typedef IceUtil::Handle<Generator> GeneratorPtr;

class RandomGenerator : public Generator
{
public:

    RandomGenerator(int seed, int max) :
        _max(max)
    {
        srand(seed);
    }

    virtual int
    next()
    {
        return rand() % _max;
    }

    virtual string
    toString()
    {
        ostringstream os;
        os << "random(" << _max << ")";
        return os.str();
    }

private:

    const int _max;
};

class SequentialGenerator : public Generator
{
public:

    SequentialGenerator(int min, int max) :
        _min(min),
        _max(max),
        _current(0)
    {
    }

    virtual int
    next()
    {
        int n = _current;
        ++_current;
        if(_current > _max)
        {
            _current = _min;
        }
        return n;
    }

    virtual string
    toString()
    {
        ostringstream os;
        os << ((_max - _min)+1);
        return os.str();
    }

private:

    const int _min;
    const int _max;
    int _current;
};

class TestApp : public Ice::Application
{
public:
    
    TestApp(const string&);

    virtual int run(int, char*[]);
    virtual void interruptCallback(int);

private:

    //
    // We need to define the template function here because of a VC6 bug :-(.
    //

    void IntIntMapIndexTest(IntIntMap&) 
    {}
    void IntIntMapIndexTest(IndexedIntIntMap&);
    template<class T> void IntIntMapTest(const string& mapName, T* = 0)
    {
        T m(_connection, mapName);      
        //
        // Populate the database.
        //
        int i;
        _watch.start();
        {
            Freeze::TransactionHolder txHolder(_connection);
            for(i = 0; i < _repetitions; ++i)
            {
#if defined(__BCPLUSPLUS__) || (defined(_MSC_VER) && (_MSC_VER < 1310))
                m.put(T::value_type(i, i));
#else
                m.put(typename T::value_type(i, i));
#endif
            }
            txHolder.commit();
        }
        IceUtil::Time total = _watch.stop();
        IceUtil::Time perRecord = total / _repetitions;

        cout << "\ttime for " << _repetitions << " writes: " << total * 1000 << "ms" << endl;
        cout << "\ttime per write: " << perRecord * 1000 << "ms" << endl;
        
        //
        // Read each record.
        //
        _watch.start();
        for(i = 0; i < _repetitions; ++i)
        {
            typename T::iterator p = m.find(i);
            test(p != m.end());
            test(p->second == i);
        }
        total = _watch.stop();
        perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " reads: " << total * 1000  << "ms" << endl;
        cout << "\ttime per read: " << perRecord * 1000 << "ms" << endl;
        
        //
        // Optional index sub-test
        //
        IntIntMapIndexTest(m);
        
        //
        // Remove each record.
        //
        _watch.start();
        {
            Freeze::TransactionHolder txHolder(_connection);
            for(i = 0; i < _repetitions; ++i)
            {
                m.erase(i);
            }
            txHolder.commit();
        }
        total = _watch.stop();
        perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " removes: " << total * 1000 << "ms" << endl;
        cout << "\ttime per remove: " << perRecord * 1000 << "ms" << endl;
    }
   
    
    void generatedReadWithIndex(IntIntMap&, int, const GeneratorPtr&)
    {}
    void generatedReadWithIndex(IndexedIntIntMap&, int, const GeneratorPtr&);
    template<class T> void generatedRead(T& m, int reads , const GeneratorPtr& gen)
    {
        _watch.start();
        for(int i = 0; i < reads; ++i)
        {
            int key = gen->next();
            typename T::iterator p = m.find(key);
            test(p != m.end());
            test(p->second == key);
        }
        IceUtil::Time total = _watch.stop();
        IceUtil::Time perRecord = total / reads;
        
        cout << "\ttime for " << reads << " reads of " << gen->toString() << " records: " << total * 1000 << "ms"
             << endl;
        cout << "\ttime per read: " << perRecord * 1000 << "ms" << endl;
        
        generatedReadWithIndex(m, reads, gen);
    }

    
    void Struct1Struct2MapIndexTest(Struct1Struct2Map&) 
    {}
    void Struct1Struct2MapIndexTest(IndexedStruct1Struct2Map&);
    template<class T> void Struct1Struct2MapTest(const string& mapName, T* = 0)
    {
        T m(_connection, mapName);
        
        //
        // Populate the database.
        //
        Struct1 s1;
        Struct2 s2;
        int i;
        _watch.start();
        {
            Freeze::TransactionHolder txHolder(_connection);
            for(i = 0; i < _repetitions; ++i)
            {
                s1.l = i;
                ostringstream os;
                os << i;
                s2.s = os.str();
                s2.s1 = s1;

#if defined(__BCPLUSPLUS__) || (defined(_MSC_VER) && (_MSC_VER < 1310))
                m.put(T::value_type(s1, s2));
#else
                m.put(typename T::value_type(s1, s2));
#endif
            }
            txHolder.commit();
        }
        IceUtil::Time total = _watch.stop();
        IceUtil::Time perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " writes: " << total * 1000 << "ms" << endl;
        cout << "\ttime per write: " << perRecord * 1000 << "ms" << endl;
        
        //
        // Read each record.
        //
        _watch.start();
        for(i = 0; i < _repetitions; ++i)
        {
            s1.l = i;
            typename T::iterator p = m.find(s1);
            test(p != m.end());
            ostringstream os;
            os << i;
            test(p->second.s == os.str());
        }
        total = _watch.stop();
        perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " reads: " << total * 1000 << "ms" << endl;
        cout << "\ttime per read: " << perRecord * 1000 << "ms" << endl;
        
        //
        // Optional index test
        //
        Struct1Struct2MapIndexTest(m);
        
        //
        // Remove each record.
        //
        _watch.start();
        {
            Freeze::TransactionHolder txHolder(_connection);
            for(i = 0; i < _repetitions; ++i)
            {
                s1.l = i;
                m.erase(s1);
            }
            txHolder.commit();
        }
        total = _watch.stop();
        perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " removes: " << total * 1000 << "ms" << endl;
        cout << "\ttime per remove: " << perRecord * 1000 << "ms" << endl;
    }

   
    void Struct1Class1MapIndexTest(Struct1Class1Map&) 
    {}
    void Struct1Class1MapIndexTest(IndexedStruct1Class1Map&);
    template<class T> void Struct1Class1MapTest(const string& mapName, T* = 0)
    {
        T m(_connection, mapName);
        
        //
        // Populate the database.
        //
        Struct1 s1;
        Class1Ptr c1 = new Class1();
        int i;
        _watch.start();
        {
            Freeze::TransactionHolder txHolder(_connection);
            for(i = 0; i < _repetitions; ++i)
            {
                s1.l = i;
                ostringstream os;
                os << i;
                c1->s = os.str();
#if defined(__BCPLUSPLUS__) || (defined(_MSC_VER) && (_MSC_VER < 1310))
                m.put(T::value_type(s1, c1));
#else
                m.put(typename T::value_type(s1, c1));
#endif
            }
            txHolder.commit();
        }
        IceUtil::Time total = _watch.stop();
        IceUtil::Time perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " writes: " << total * 1000 << "ms" << endl;
        cout << "\ttime per write: " << perRecord * 1000 << "ms" << endl;
        
        //
        // Read each record.
        //
        _watch.start();
        for(i = 0; i < _repetitions; ++i)
        {
            s1.l = i;
            typename T::iterator p = m.find(s1);
            test(p != m.end());
            ostringstream os;
            os << i;
            test(p->second->s == os.str());
        }
        total = _watch.stop();
        perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " reads: " << total * 1000 << "ms" << endl;
        cout << "\ttime per read: " << perRecord * 1000 << "ms" << endl;
        
        //
        // Optional index test
        //
        
        Struct1Class1MapIndexTest(m);
        
        //
        // Remove each record.
        //
        _watch.start();
        {
            Freeze::TransactionHolder txHolder(_connection);
            for(i = 0; i < _repetitions; ++i)
            {
                s1.l = i;
                m.erase(s1);
            }
            txHolder.commit();
        }
        total = _watch.stop();
        perRecord = total / _repetitions;
        
        cout << "\ttime for " << _repetitions << " removes: " << total * 1000 << "ms" << endl;
        cout << "\ttime per remove: " << perRecord * 1000 << "ms" << endl;
    }
   
    void IntIntMapReadIndexTest(IntIntMap&)
    {}
    void IntIntMapReadIndexTest(IndexedIntIntMap&);
    template<class T> void IntIntMapReadTest(const string& mapName, T* = 0)