netrq/test/test1.cpp

Go to the documentation of this file.

/*
 * test1.cpp
 *
 * Copyright (C) 2009  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.
 *
 * Quick tests for the netrq (network request queue) library.
 */

// includes --------------------------------------------------------------------
#include "netrq/netrq.h"                // include library header first

#include <iostream>

#include "common/wave_ex.h"
#include "perf/perf.h"


// statics ---------------------------------------------------------------------
static const int s_maxByteSize          = 255;

static char s_testMessage[s_maxByteSize];


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

class TestRequest : public netrq::Request {
public:
        virtual ~TestRequest(void) throw() { }

        // netrq::Request class interface methods ------------------------------
        const char * getId(void) const throw() {
                        return m_id.c_str();
                }
        int getMaxBytes(void) const throw() {
                        // our message size plus packlet header
                        return m_nBytes + 2;
                }
        void write(IO xdrbuf::Output * output) {
                        ASSERT(output, "null");
                        output->addStringPacklet('s', s_testMessage, m_nBytes);
                }

        // public factory methods ----------------------------------------------
        static smart_ptr<TestRequest> create(IN int nBytes) {
                        ASSERT(nBytes > 0, "Bad byte count: %d", nBytes);
                        ASSERT(nBytes < s_maxByteSize, "too many bytes: %d",
                            nBytes);
                        smart_ptr<TestRequest> local = new TestRequest;
                        ASSERT(local, "out of memory");
                        local->m_nBytes = nBytes;

                        char buffer[32];
                        sprintf(buffer, "id-%d", rand() % 128);
                        local->m_id = buffer;

                        return local;
                }

private:
        std::string     m_id;
        int             m_nBytes;
};



bool
addRandomRequest
(
IO netrq::Queue * queue
)
{
        ASSERT(queue, "null");

        int nBytes = 32 + (rand() % (s_maxByteSize - 33));
        smart_ptr<netrq::Request> request = TestRequest::create(nBytes);
        ASSERT(request, "null");

        dword_t clock = 1 + (rand() % 32);
        netrq::Queue::eInsertResult result = queue->addRequest(clock, request);
        if (netrq::Queue::eQueue_Failed_CurrentEntryHasLaterClock == result) {
        //      DPRINTF("Failed to add request--forcing deletion of existing");
                const char * id = request->getId();
                if (!queue->removeRequest(id)) {
                        WAVE_EX(wex);
                        wex << "Failed to remove existing request?";
                }
                result = queue->addRequest(clock, request);
                if (netrq::Queue::eQueue_Success != result) {
                        WAVE_EX(wex);
                        wex << "Failed to re-insert after deleting colliding entry";
                }

                return true;
        }

        return false;   // no removals required
}



void
doTest1
(
IN int bufSize,
IN int nMessages,
IN int nLoops
)
{
        ASSERT(bufSize > 0, "Bad output buffer size: %d", bufSize);
        ASSERT(nMessages > 0, "Bad message count: %d", nMessages);
        ASSERT(nLoops > 0, "Bad loop count: %d", nLoops);

        // first, create output buffer
        smart_ptr<xdrbuf::Output> output = xdrbuf::Output::create(bufSize);
        ASSERT(output, "null");

        // next, create and populate network queue
        int removalCount = 0;
        smart_ptr<netrq::Queue> queue = netrq::Queue::create();
        ASSERT(queue, "null");
        for (int i = 0; i < nMessages; ++i) {
                if (addRandomRequest(queue)) {
                        ++removalCount;
                }
        }
        DPRINTF("Had to remove %d requests due to collisions", removalCount);
        DPRINTF("Total queue size: %d requests", queue->size());

        // finally, loop and send
        dword_t clock = 1;
        for (int i = 0; i < nLoops; ++i) {
                output->clear();
                int nSent = netrq::sendMessagesFromQueue(output, clock, queue);
                if (nSent) {
                        DPRINTF("Clock %lu: sent %d messages", (long) clock,
                            nSent);
                }
                ++clock;
        }
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        try {
                perf::Timer timer("overall timer");

                // set up the test buffer message
                for (int i = 0; i < s_maxByteSize; ++i) {
                        s_testMessage[i] = 'a';
                }
                s_testMessage[s_maxByteSize - 1] = 0;

                // run tests
                doTest1(500, 200, 200);
                doTest1(255, 200, 200);
                doTest1(8192, 2048, 200);
        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                retval = 1;
        } catch (...) {
                DPRINTF("Unknown exception!");
                retval = 2;
        }
        perf::dumpTimingSummary(std::cerr);

        return retval;
}