6:01 p.m.
Author: kpvdr
Date: 2010-12-07 12:01:24 -0500 (Tue, 07 Dec 2010)
New Revision: 4428
Modified:
store/trunk/cpp/lib/jrnl2/JournalParameters.cpp
store/trunk/cpp/lib/jrnl2/JournalParameters.hpp
store/trunk/cpp/perf/JournalInstance.cpp
store/trunk/cpp/perf/JournalInstance.hpp
store/trunk/cpp/perf/JournalParameters.cpp
store/trunk/cpp/perf/JournalParameters.hpp
store/trunk/cpp/perf/ScopedPerformanceTimer.cpp
store/trunk/cpp/perf/ScopedPerformanceTimer.hpp
store/trunk/cpp/perf/StorePerformanceTest.cpp
store/trunk/cpp/perf/StorePerformanceTest.hpp
store/trunk/cpp/perf/TestParameters.cpp
store/trunk/cpp/perf/TestParameters.hpp
Log:
Code tidy-up for the perf tool
Modified: store/trunk/cpp/lib/jrnl2/JournalParameters.cpp
===================================================================
--- store/trunk/cpp/lib/jrnl2/JournalParameters.cpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/lib/jrnl2/JournalParameters.cpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -90,7 +90,7 @@
{}
std::string
-JournalParameters::to_string()
+JournalParameters::toString()
{
std::ostringstream oss;
oss << "Store Parameters:" << std::endl;
Modified: store/trunk/cpp/lib/jrnl2/JournalParameters.hpp
===================================================================
--- store/trunk/cpp/lib/jrnl2/JournalParameters.hpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/lib/jrnl2/JournalParameters.hpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -70,7 +70,7 @@
const u_int16_t writeBuffNumPgs,
const u_int32_t writeBuffPgSize_sblks);
JournalParameters(const JournalParameters& sp);
- std::string to_string();
+ std::string toString();
};
} // namespace journal2
Modified: store/trunk/cpp/perf/JournalInstance.cpp
===================================================================
--- store/trunk/cpp/perf/JournalInstance.cpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/JournalInstance.cpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -35,27 +35,27 @@
namespace mrg
{
-namespace test
+namespace jtest
{
-JournalInstance::JournalInstance(const uint32_t num_msgs,
- const uint32_t msg_size,
- const char* msg_data,
+JournalInstance::JournalInstance(const uint32_t numMsgs,
+ const uint32_t msgSize,
+ const char* msgData,
#ifdef JOURNAL2
- mrg::journal2::jrnl* const jp) :
+ mrg::journal2::jrnl* const jrnlPtr) :
#else
- mrg::journal::jcntl* const jp) :
+ mrg::journal::jcntl* const jrnlPtr) :
#endif
- _num_msgs(num_msgs),
- _msg_size(msg_size),
- _msg_data(msg_data),
- _jp(jp),
- _thread_switch(false)
+ _numMsgs(numMsgs),
+ _msgSize(msgSize),
+ _msgData(msgData),
+ _jrnlPtr(jrnlPtr),
+ _threadSwitch(false)
{}
JournalInstance::~JournalInstance()
{
- delete _jp;
+ delete _jrnlPtr;
}
@@ -63,19 +63,19 @@
// This method will be called by multiple threads simultaneously
// Enqueue thread entry point
void
-JournalInstance::_enq()
+JournalInstance::_doEnqueues()
{
bool misfireFlag = false;
uint32_t i = 0;
- while (i < _num_msgs) {
+ while (i < _numMsgs) {
#ifdef JOURNAL2
- mrg::journal2::dtok* dtokp = new mrg::journal2::dtok();
- mrg::journal2::iores res = _jp->enqueue(_msg_data, _msg_size, dtokp);
+ mrg::journal2::dtok* dtokPtr = new mrg::journal2::dtok();
+ mrg::journal2::iores jrnlIoRes = _jrnlPtr->enqueue(_msgData, _msgSize,
dtokPtr);
#else
- mrg::journal::data_tok* dtokp = new mrg::journal::data_tok();
- mrg::journal::iores res = _jp->enqueue_data_record(_msg_data, _msg_size,
_msg_size, dtokp);
+ mrg::journal::data_tok* dtokPtr = new mrg::journal::data_tok();
+ mrg::journal::iores jrnlIoRes = _jrnlPtr->enqueue_data_record(_msgData,
_msgSize, _msgSize, dtokPtr);
#endif
- switch (res) {
+ switch (jrnlIoRes) {
#ifdef JOURNAL2
case 0:
#else
@@ -90,7 +90,7 @@
case mrg::journal::RHM_IORES_BUSY:
#endif
if (!misfireFlag) std::cout << "-" << std::flush;
- delete dtokp;
+ delete dtokPtr;
misfireFlag = true;
break;
#ifdef JOURNAL2
@@ -98,23 +98,23 @@
#else
case mrg::journal::RHM_IORES_ENQCAPTHRESH:
#endif
- //std::cout << "_enq() RHM_IORES_ENQCAPTHRESH: " <<
dtokp->status_str() << std::endl;
+ //std::cout << "_doEnqueues() RHM_IORES_ENQCAPTHRESH: "
<< dtokPtr->status_str() << std::endl;
if (!misfireFlag) std::cout << "*" << std::flush;
//std::cout << ".";
- delete dtokp;
+ delete dtokPtr;
misfireFlag = true;
::usleep(10);
break;
default:
- delete dtokp;
+ delete dtokPtr;
#ifdef JOURNAL2
- std::cerr << "enqueue_data_record FAILED with " <<
mrg::journal2::iores_str(res) << std::endl;
+ std::cerr << "enqueue_data_record FAILED with " <<
mrg::journal2::iores_str(jrnlIoRes) << std::endl;
#else
- std::cerr << "enqueue_data_record FAILED with " <<
mrg::journal::iores_str(res) << std::endl;
+ std::cerr << "enqueue_data_record FAILED with " <<
mrg::journal::iores_str(jrnlIoRes) << std::endl;
#endif
}
}
- _jp->flush(false);
+ _jrnlPtr->flush(false);
}
@@ -122,38 +122,38 @@
// This method will be called by multiple threads simultaneously
// Dequeue thread entry point
void
-JournalInstance::_deq()
+JournalInstance::_doDequeues()
{
uint32_t i = 0;
- while (i < _num_msgs) {
+ while (i < _numMsgs) {
#ifdef JOURNAL2
- mrg::journal2::dtok* dtokp = 0;
+ mrg::journal2::dtok* dtokPtr = 0;
#else
- mrg::journal::data_tok* dtokp = 0;
+ mrg::journal::data_tok* dtokPtr = 0;
#endif
- while (!dtokp) {
- bool get_events_flag;
+ while (!dtokPtr) {
+ bool getEventsFlag;
{
- std::unique_lock<std::mutex> l(_ucl_mutex);
- get_events_flag = _ucl.size() == 0;
- if (!get_events_flag) {
- dtokp = _ucl.front();
- _ucl.pop();
+ std::unique_lock<std::mutex> l(_unprocCallbackListMutex);
+ getEventsFlag = _unprocCallbackList.size() == 0;
+ if (!getEventsFlag) {
+ dtokPtr = _unprocCallbackList.front();
+ _unprocCallbackList.pop();
}
}
- if (get_events_flag) {
- _jp->get_wr_events(0);
+ if (getEventsFlag) {
+ _jrnlPtr->get_wr_events(0);
::usleep(1);
}
}
bool done = false;
while (!done) {
#ifdef JOURNAL2
- mrg::journal2::iores res = _jp->dequeue(dtokp);
+ mrg::journal2::iores jrnlIoRes = _jrnlPtr->dequeue(dtokPtr);
#else
- mrg::journal::iores res = _jp->dequeue_data_record(dtokp);
+ mrg::journal::iores jrnlIoRes = _jrnlPtr->dequeue_data_record(dtokPtr);
#endif
- switch (res) {
+ switch (jrnlIoRes) {
#ifdef JOURNAL2
case 0:
#else
@@ -171,36 +171,38 @@
break;
default:
#ifdef JOURNAL2
- std::cerr << "dequeue_data_record FAILED with "
<< mrg::journal2::iores_str(res) << ": " <<
dtokp->status_str() << std::endl;
+ std::cerr << "dequeue_data_record FAILED with "
<< mrg::journal2::iores_str(jrnlIoRes) << ": "
+ << dtokPtr->status_str() << std::endl;
#else
- std::cerr << "dequeue_data_record FAILED with "
<< mrg::journal::iores_str(res) << ": " <<
dtokp->status_str() << std::endl;
+ std::cerr << "dequeue_data_record FAILED with "
<< mrg::journal::iores_str(jrnlIoRes) << ": "
+ << dtokPtr->status_str() << std::endl;
#endif
- delete dtokp;
+ delete dtokPtr;
done = true;
}
}
- _jp->get_wr_events(0);
+ _jrnlPtr->get_wr_events(0);
}
- _jp->flush(true);
+ _jrnlPtr->flush(true);
}
// *** MUST BE THREAD-SAFE ****
// This method will be called by multiple threads simultaneously
// Main thread entry point.
-// _thread_switch flips on each entry; this makes alternate threads run _enq() and
_deq()
+// _threadSwitch flips on each call; this makes alternate threads run _doEnqueues() and
_doDequeues()
void
JournalInstance::operator()()
{
- bool ts;
+ bool localThreadSwitch;
{
std::lock_guard<std::mutex> l(_ts_lock);
- ts = _thread_switch;
- _thread_switch = !_thread_switch;
+ localThreadSwitch = _threadSwitch;
+ _threadSwitch = !_threadSwitch;
}
- if (ts) {
- _deq();
+ if (localThreadSwitch) {
+ _doDequeues();
} else {
- _enq();
+ _doEnqueues();
}
}
@@ -208,35 +210,35 @@
// This method will be called by multiple threads simultaneously
void
#ifdef JOURNAL2
-JournalInstance::wr_aio_cb(std::vector<mrg::journal2::dtok*>& dtokl)
+JournalInstance::wr_aio_cb(std::vector<mrg::journal2::dtok*>& dataTokenList)
{
- mrg::journal2::dtok* dtokp;
+ mrg::journal2::dtok* dtokPtr;
#else
-JournalInstance::wr_aio_cb(std::vector<mrg::journal::data_tok*>& dtokl)
+JournalInstance::wr_aio_cb(std::vector<mrg::journal::data_tok*>&
dataTokenList)
{
- mrg::journal::data_tok* dtokp;
+ mrg::journal::data_tok* dtokPtr;
#endif
- while (dtokl.size())
+ while (dataTokenList.size())
{
- dtokp = dtokl.back();
- dtokl.pop_back();
+ dtokPtr = dataTokenList.back();
+ dataTokenList.pop_back();
#ifdef JOURNAL2
- switch (dtokp->get_dtok_state().get_op_state())
+ switch (dtokPtr->get_dtok_state().get_op_state())
{
case mrg::journal2::OP_ENQUEUE:
#else
- switch (dtokp->wstate())
+ switch (dtokPtr->wstate())
{
case mrg::journal::data_tok::ENQ:
#endif
{
- std::unique_lock<std::mutex> l(_ucl_mutex);
- _ucl.push(dtokp);
+ std::unique_lock<std::mutex> l(_unprocCallbackListMutex);
+ _unprocCallbackList.push(dtokPtr);
}
break;
default:
- delete dtokp;
+ delete dtokPtr;
}
}
}
@@ -244,8 +246,8 @@
// *** MUST BE THREAD-SAFE ****
// This method will be called by multiple threads simultaneously
void
-JournalInstance::rd_aio_cb(std::vector<uint16_t>& /*pil*/)
+JournalInstance::rd_aio_cb(std::vector<uint16_t>&
/*buffPageCtrlBlkIndexList*/)
{}
-} // namespace test
+} // namespace jtest
} // namespace mrg
Modified: store/trunk/cpp/perf/JournalInstance.hpp
===================================================================
--- store/trunk/cpp/perf/JournalInstance.hpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/JournalInstance.hpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -29,12 +29,12 @@
* The GNU Lesser General Public License is available in the file COPYING.
*/
-#ifndef mrg_test_JournalInstance_hpp
-#define mrg_test_JournalInstance_hpp
+#ifndef mrg_jtest_JournalInstance_hpp
+#define mrg_jtest_JournalInstance_hpp
#include <cstdint>
+#include <mutex>
#include <queue>
-#include <mutex>
#ifdef JOURNAL2
#include "jrnl2/aio_callback.hpp"
@@ -48,48 +48,130 @@
namespace mrg
{
-namespace test
+namespace jtest
{
+ /**
+ * \brief Test journal instance. Each queue to be tested results in one instance of
this class.
+ *
+ * Journal test harness which contains the journal to be tested. Each queue to be
tested in the test parameters
+ * results in one instance of this class being instantiated, and consequently one set
of journals on disk. The
+ * journal instance is provided as a pointer to the constructor.
+ */
#ifdef JOURNAL2
class JournalInstance: public mrg::journal2::aio_callback
#else
class JournalInstance: public mrg::journal::aio_callback
#endif
{
- const uint32_t _num_msgs;
- const uint32_t _msg_size;
- const char* _msg_data;
+ const uint32_t _numMsgs; ///< Number of messages to be
processed by this journal instance
+ const uint32_t _msgSize; ///< Size of each message (in bytes)
+ const char* _msgData; ///< Pointer to message content to be
used for each message.
#ifdef JOURNAL2
- mrg::journal2::jrnl* const _jp;
- std::queue<mrg::journal2::dtok*> _ucl;
+ mrg::journal2::jrnl* const _jrnlPtr; ///< Journal instance pointer
+ std::queue<mrg::journal2::dtok*> _unprocCallbackList; ///< Queue of
unprocessed callbacks to be dequeued
#else
- mrg::journal::jcntl* const _jp;
- std::queue<mrg::journal::data_tok*> _ucl;
+ mrg::journal::jcntl* const _jrnlPtr; ///< Journal instance pointer
+ std::queue<mrg::journal::data_tok*> _unprocCallbackList; ///< Queue of
unprocessed callbacks to be dequeued
#endif
- std::mutex _ucl_mutex;
- bool _thread_switch;
+ std::mutex _unprocCallbackListMutex; ///< Mutex which protects the
unprocessed callback queue
+ bool _threadSwitch; ///< A switch which alternates worker
threads between enq and deq
+ std::mutex _ts_lock; ///< Mutex which protects the thread
switch
- std::mutex _ts_lock;
- void _enq();
- void _deq();
+ /**
+ * \brief Worker thread enqueue task
+ *
+ * This function is the worker thread enqueue task entry point. It enqueues
_numMsgs onto the journal instance.
+ * A data tokens is created for each record, this is the start of the data token
life cycle. All possible
+ * returns from the journal are handled appropriately. Since the enqueue threads
also perform
+ * callbacks on completed AIO operations, the data tokens from completed enqueues
are placed onto the
+ * unprocessed callback list (_unprocCallbackList) for dequeueing by the dequeue
worker thread(s).
+ *
+ * This function must be thread safe.
+ */
+ void _doEnqueues();
+
+ /**
+ * \brief Worker thread dequeue task
+ *
+ * This function is the worker thread dequeue task entry point. It dequeues
messages which are on the
+ * unprocessed callback list (_unprocCallbackList).
+ *
+ * This function must be thread safe.
+ */
+ void _doDequeues();
+
public:
+ /**
+ * \brief Constructor
+ *
+ * Constructor.
+ *
+ * \param numMsgs Number of messages per thread to be enqueued then dequeued (ie
both ways through broker)
+ * \param msgSize Size of each message being enqueued
+ * \param msgData Pointer to message content (all messages have identical
content)
+ * \param jrnlPtr Pinter to journal instance which is to be tested
+ */
#ifdef JOURNAL2
- JournalInstance(const uint32_t num_msgs, const uint32_t msg_size, const char*
msg_data, mrg::journal2::jrnl* const jp);
+ JournalInstance(const uint32_t numMsgs,
+ const uint32_t msgSize,
+ const char* msgData,
+ mrg::journal2::jrnl* const jrnlPtr);
#else
- JournalInstance(const uint32_t num_msgs, const uint32_t msg_size, const char*
msg_data, mrg::journal::jcntl* const jp);
+ JournalInstance(const uint32_t numMsgs,
+ const uint32_t msgSize,
+ const char* msgData,
+ mrg::journal::jcntl* const jrnlPtr);
#endif
+
+ /**
+ * \brief Destructor
+ *
+ * Destructor.
+ */
virtual ~JournalInstance();
+
+ /**
+ * \brief Worker thread entry point used by std::thread for classes. Threads must
be provided in pairs.
+ *
+ * This is the entry point for worker threads. To successfully use this class,
threads must be provided in
+ * pairs, with alternate threads being used for enqueueing and deqeueing tasks
(_doEnqueues and _doDequeues
+ * respectively). See these functions for more detail on these tasks. The bool
member _threadSwitch is
+ * responsible for alternating threads calling this function between these two
tasks.
+ */
void operator()();
+
+ /**
+ * \brief Write callback function. When AIO operations return, this function is
called.
+ *
+ * When AIO operations return, this function will sort the enqueue ops from the
rest and place the data tokens
+ * of these records onto the unprocessed callback list (_unprocCallbackList) for
dequeueing by another thread.
+ *
+ * Returning dequeue ops have their data tokens destroyed, as this is the end of
the life cycle of the data
+ * tokens.
+ *
+ * Required by all subclasses of mrg::journal::aio_callback.
+ *
+ * \param dataTokenList A vector of data tokens for those messages which have
completed their AIO write
+ * operations
+ */
#ifdef JOURNAL2
- void wr_aio_cb(std::vector<mrg::journal2::dtok*>& dtokl);
+ void wr_aio_cb(std::vector<mrg::journal2::dtok*>& dataTokenList);
#else
- void wr_aio_cb(std::vector<mrg::journal::data_tok*>& dtokl);
+ void wr_aio_cb(std::vector<mrg::journal::data_tok*>& dataTokenList);
#endif
- void rd_aio_cb(std::vector<uint16_t>& pil);
+
+ /**
+ * \brief Read callback function. When read AIO operations return, this function
is called.
+ *
+ * Not used in this test, but required by all subclasses of
mrg::journal::aio_callback.
+ *
+ * \param buffPageCtrlBlkIndexList A vector of indices to the buffer page control
blocks for completed reads
+ */
+ void rd_aio_cb(std::vector<uint16_t>& buffPageCtrlBlkIndexList);
};
-} // namespace test
+} // namespace jtest
} // namespace mrg
-#endif // mrg_test_JournalInstance_hpp
+#endif // mrg_jtest_JournalInstance_hpp
Modified: store/trunk/cpp/perf/JournalParameters.cpp
===================================================================
--- store/trunk/cpp/perf/JournalParameters.cpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/JournalParameters.cpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -35,7 +35,7 @@
namespace mrg
{
-namespace test
+namespace jtest
{
// static declarations
@@ -62,9 +62,9 @@
JournalParameters::JournalParameters(const std::string& jrnlDir,
const std::string& jrnlBaseFileName,
const uint16_t numJrnlFiles,
+ const uint32_t jrnlFileSize_sblks,
const bool autoExpand,
const uint16_t autoExpandMaxJrnlFiles,
- const uint32_t jrnlFileSize_sblks,
const uint16_t writeBuffNumPgs,
const uint32_t writeBuffPgSize_sblks) :
_jrnlDir(jrnlDir),
@@ -77,33 +77,39 @@
_writeBuffPgSize_sblks(writeBuffPgSize_sblks)
{}
-JournalParameters::JournalParameters(const JournalParameters& sp) :
- _jrnlDir(sp._jrnlDir),
- _jrnlBaseFileName(sp._jrnlBaseFileName),
- _numJrnlFiles(sp._numJrnlFiles),
- _jrnlFileSize_sblks(sp._jrnlFileSize_sblks),
- _autoExpand(sp._autoExpand),
-
_autoExpandMaxJrnlFiles(sp._autoExpandMaxJrnlFiles),
- _writeBuffNumPgs(sp._writeBuffNumPgs),
- _writeBuffPgSize_sblks(sp._writeBuffPgSize_sblks)
+JournalParameters::JournalParameters(const JournalParameters& jp) :
+ _jrnlDir(jp._jrnlDir),
+ _jrnlBaseFileName(jp._jrnlBaseFileName),
+ _numJrnlFiles(jp._numJrnlFiles),
+ _jrnlFileSize_sblks(jp._jrnlFileSize_sblks),
+ _autoExpand(jp._autoExpand),
+
_autoExpandMaxJrnlFiles(jp._autoExpandMaxJrnlFiles),
+ _writeBuffNumPgs(jp._writeBuffNumPgs),
+ _writeBuffPgSize_sblks(jp._writeBuffPgSize_sblks)
{}
+void
+JournalParameters::toStream(std::ostream& os)
+{
+ os << "Store Parameters:" << std::endl;
+ os << " jrnlDir = \"" << _jrnlDir <<
"\"" << std::endl;
+ os << " jrnlBaseFileName = \"" << _jrnlBaseFileName
<< "\"" << std::endl;
+ os << " numJrnlFiles = " << _numJrnlFiles << std::endl;
+ os << " jrnlFileSize_sblks = " << _jrnlFileSize_sblks <<
std::endl;
+ os << " autoExpand = " << _autoExpand << std::endl;
+ os << " autoExpandMaxJrnlFiles = " << _autoExpandMaxJrnlFiles
<< std::endl;
+ os << " writeBuffNumPgs = " << _writeBuffNumPgs <<
std::endl;
+ os << " writeBuffPgSize_sblks = " << _writeBuffPgSize_sblks
<< std::endl;
+}
+
std::string
-JournalParameters::to_string()
+JournalParameters::toString()
{
std::ostringstream oss;
- oss << "Store Parameters:" << std::endl;
- oss << " jrnlDir = \"" << _jrnlDir <<
"\"" << std::endl;
- oss << " jrnlBaseFileName = \"" << _jrnlBaseFileName
<< "\"" << std::endl;
- oss << " numJrnlFiles = " << _numJrnlFiles <<
std::endl;
- oss << " jrnlFileSize_sblks = " << _jrnlFileSize_sblks
<< std::endl;
- oss << " autoExpand = " << _autoExpand << std::endl;
- oss << " autoExpandMaxJrnlFiles = " << _autoExpandMaxJrnlFiles
<< std::endl;
- oss << " writeBuffNumPgs = " << _writeBuffNumPgs <<
std::endl;
- oss << " writeBuffPgSize_sblks = " << _writeBuffPgSize_sblks
<< std::endl;
+ toStream(oss);
return oss.str();
}
-} // namespace test
+} // namespace jtest
} // namespace mrg
Modified: store/trunk/cpp/perf/JournalParameters.hpp
===================================================================
--- store/trunk/cpp/perf/JournalParameters.hpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/JournalParameters.hpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -29,15 +29,16 @@
* The GNU Lesser General Public License is available in the file COPYING.
*/
-#ifndef mrg_test_JournalParameters_hpp
-#define mrg_test_JournalParameters_hpp
+#ifndef mrg_jtest_JournalParameters_hpp
+#define mrg_jtest_JournalParameters_hpp
#include <cstdint>
+#include <iostream>
#include <string>
namespace mrg
{
-namespace test
+namespace jtest
{
/**
@@ -78,13 +79,22 @@
* \brief Constructor
*
* Convenience constructor.
+ *
+ * \param jrnlDir Journal directory
+ * \param jrnlBaseFileName Journal base file name
+ * \param numJrnlFiles Number of journal data files
+ * \param jrnlFileSize_sblks Journal data file size in softblocks
+ * \param autoExpand Auto-expand flag (allows auto-expansion of journal data
files)
+ * \param autoExpandMaxJrnlFiles Default auto-expand file number limit (0 = no
limit)
+ * \param writeBuffNumPgs Number of write buffer pages
+ * \param writeBuffPgSize_sblks Size of each write buffer page in softblocks
*/
JournalParameters(const std::string& jrnlDir,
const std::string& jrnlBaseFileName,
const uint16_t numJrnlFiles,
+ const uint32_t jrnlFileSize_sblks,
const bool autoExpand,
const uint16_t autoExpandMaxJrnlFiles,
- const uint32_t jrnlFileSize_sblks,
const uint16_t writeBuffNumPgs,
const uint32_t writeBuffPgSize_sblks);
@@ -92,21 +102,33 @@
* \brief Copy constructor
*
* Copy constructor.
+ *
+ * \param jp Reference to JournalParameters instance to be copied
*/
- JournalParameters(const JournalParameters& sp);
+ JournalParameters(const JournalParameters& jp);
+ /***
+ * \brief Stream the journal parameters to an output stream
+ *
+ * Convenience feature which streams a multi-line representation of all the
journal parameters, one per line to
+ * an output stream.
+ *
+ * \param os Output stream to which the class data is to be streamed
+ */
+ void toStream(std::ostream& os = std::cout);
+
/**
* \brief Creates a string representation of the journal parameters
*
- * Convenience feature which creates a multi-line string representation of all
the parameters, one parameter per
+ * Convenience feature which creates a multi-line string representation of all
the journal parameters, one per
* line.
*
* \return multi-line string representation of all the parameters, one parameter
per line.
*/
- std::string to_string();
+ std::string toString();
};
-} // namespace test
+} // namespace jtest
} // namespace mrg
-#endif // mrg_test_JournalParameters_hpp
+#endif // mrg_jtest_JournalParameters_hpp
Modified: store/trunk/cpp/perf/ScopedPerformanceTimer.cpp
===================================================================
--- store/trunk/cpp/perf/ScopedPerformanceTimer.cpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/ScopedPerformanceTimer.cpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -33,7 +33,7 @@
namespace mrg
{
-namespace test
+namespace jtest
{
ScopedPerformanceTimer::ScopedPerformanceTimer(const TestParameters& tp,
std::ostream& os) :
@@ -68,5 +68,5 @@
}
-} // namespace test
+} // namespace jtest
} // namespace mrg
Modified: store/trunk/cpp/perf/ScopedPerformanceTimer.hpp
===================================================================
--- store/trunk/cpp/perf/ScopedPerformanceTimer.hpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/ScopedPerformanceTimer.hpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -29,8 +29,8 @@
* The GNU Lesser General Public License is available in the file COPYING.
*/
-#ifndef mrg_test_ScopedPerformanceTimer_hpp
-#define mrg_test_ScopedPerformanceTimer_hpp
+#ifndef mrg_jtest_ScopedPerformanceTimer_hpp
+#define mrg_jtest_ScopedPerformanceTimer_hpp
#include <cstdint>
#include <ctime>
@@ -40,7 +40,7 @@
namespace mrg
{
-namespace test
+namespace jtest
{
/**
@@ -100,7 +100,7 @@
~ScopedPerformanceTimer();
};
-} // namespace test
+} // namespace jtest
} // namespace mrg
-#endif // mrg_test_ScopedPerformanceTimer_hpp
+#endif // mrg_jtest_ScopedPerformanceTimer_hpp
Modified: store/trunk/cpp/perf/StorePerformanceTest.cpp
===================================================================
--- store/trunk/cpp/perf/StorePerformanceTest.cpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/StorePerformanceTest.cpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -53,7 +53,7 @@
namespace mrg
{
-namespace test
+namespace jtest
{
#ifdef JOURNAL2
@@ -61,59 +61,59 @@
#else
StorePerformanceTest::StorePerformanceTest(const TestParameters& tp, const
JournalParameters& jp) :
#endif
- _test_params(tp),
- _store_params(jp),
- _msg_data(new char[tp._msgSize])
+ _testParams(tp),
+ _jrnlParams(jp),
+ msgData(new char[tp._msgSize])
{}
StorePerformanceTest::~StorePerformanceTest()
{
- while (_tests.size())
+ while (_jrnlList.size())
{
- delete _tests.back();
- _tests.pop_back();
+ delete _jrnlList.back();
+ _jrnlList.pop_back();
}
- delete[] _msg_data;
+ delete[] msgData;
}
void
-StorePerformanceTest::_prepare_journals()
+StorePerformanceTest::_prepareJournals()
{
#ifdef JOURNAL2
- if (mrg::journal2::jdir::exists(_store_params._jrnlDir)) {
- mrg::journal2::jdir::delete_dir(_store_params._jrnlDir);
+ if (mrg::journal2::jdir::exists(_jrnlParams._jrnlDir)) {
+ mrg::journal2::jdir::delete_dir(_jrnlParams._jrnlDir);
}
- mrg::journal2::jdir::create_dir(_store_params._jrnlDir);
+ mrg::journal2::jdir::create_dir(_jrnlParams._jrnlDir);
mrg::journal2::jrnl* jp;
#else
- if (mrg::journal::jdir::exists(_store_params._jrnlDir)) {
- mrg::journal::jdir::delete_dir(_store_params._jrnlDir);
+ if (mrg::journal::jdir::exists(_jrnlParams._jrnlDir)) {
+ mrg::journal::jdir::delete_dir(_jrnlParams._jrnlDir);
}
- mrg::journal::jdir::create_dir(_store_params._jrnlDir);
+ mrg::journal::jdir::create_dir(_jrnlParams._jrnlDir);
mrg::journal::jcntl* jp;
#endif
JournalInstance* ptp;
- for (uint16_t j = 0; j < _test_params._numQueues; j++)
+ for (uint16_t j = 0; j < _testParams._numQueues; j++)
{
std::ostringstream jname;
jname << "jrnl_" << std::setw(4) <<
std::setfill('0') << j;
std::ostringstream jdir;
- jdir << _store_params._jrnlDir << "/" <<
jname.str();
+ jdir << _jrnlParams._jrnlDir << "/" << jname.str();
#ifdef JOURNAL2
- jp = new mrg::journal2::jrnl(jname.str(), jdir.str(),
_store_params._jrnlBaseFileName);
+ jp = new mrg::journal2::jrnl(jname.str(), jdir.str(),
_jrnlParams._jrnlBaseFileName);
#else
- jp = new mrg::journal::jcntl(jname.str(), jdir.str(),
_store_params._jrnlBaseFileName);
+ jp = new mrg::journal::jcntl(jname.str(), jdir.str(),
_jrnlParams._jrnlBaseFileName);
#endif
- ptp = new JournalInstance(_test_params._numMsgs, _test_params._msgSize,
_msg_data, jp);
+ ptp = new JournalInstance(_testParams._numMsgs, _testParams._msgSize, msgData,
jp);
#ifdef JOURNAL2
- jp->initialize(&_store_params, ptp);
+ jp->initialize(&_jrnlParams, ptp);
#else
- jp->initialize(_store_params._numJrnlFiles, _store_params._autoExpand,
_store_params._autoExpandMaxJrnlFiles,
- _store_params._jrnlFileSize_sblks,
_store_params._writeBuffNumPgs,
- _store_params._writeBuffPgSize_sblks, ptp);
+ jp->initialize(_jrnlParams._numJrnlFiles, _jrnlParams._autoExpand,
_jrnlParams._autoExpandMaxJrnlFiles,
+ _jrnlParams._jrnlFileSize_sblks, _jrnlParams._writeBuffNumPgs,
+ _jrnlParams._writeBuffPgSize_sblks, ptp);
#endif
- _tests.push_back(ptp);
+ _jrnlList.push_back(ptp);
}
}
@@ -122,17 +122,17 @@
{
std::deque<std::thread*> threads;
std::thread* tp;
- _prepare_journals();
+ _prepareJournals();
{
// --- Start of timed section ---
- ScopedPerformanceTimer pt(_test_params);
+ ScopedPerformanceTimer pt(_testParams);
- for (uint16_t q=0; q<_test_params._numQueues; q++)
+ for (uint16_t q=0; q<_testParams._numQueues; q++)
{
// Launch threads in pairs
- for (uint16_t t=0; t<_test_params._numThreadPairsPerQueue * 2; t++)
+ for (uint16_t t=0; t<_testParams._numThreadPairsPerQueue * 2; t++)
{
- tp = new std::thread(std::ref(*_tests[q]));
+ tp = new std::thread(std::ref(*_jrnlList[q]));
threads.push_back(tp);
}
}
@@ -149,67 +149,67 @@
}
void
-print_args()
+printArgs(std::ostream& os)
{
- std::cout << " -h --help: This help message"
<< std::endl;
- std::cout << std::endl;
- std::cout << "Test params:" << std::endl;
- std::cout << " -M --num_msgs: Number of messages to send
["
+ os << " -h --help: This help message" <<
std::endl;
+ os << std::endl;
+ os << "Test params:" << std::endl;
+ os << " -M --num_msgs: Number of messages to send
["
<< TestParameters::_s_defaultNumMsgs << "]" <<
std::endl;
- std::cout << " -S --msg_size: Size of each message to be
sent ["
+ os << " -S --msg_size: Size of each message to be sent
["
<< TestParameters::_s_defaultMsgSize << "]" <<
std::endl;
- std::cout << " -Q --num_queues: Number of simultaneous
queues ["
+ os << " -Q --num_queues: Number of simultaneous queues
["
<< TestParameters::_s_defaultNumQueues << "]"
<< std::endl;
- std::cout << " -T --num_thread_pairs_per_queue: Number of thread pairs per
queue ["
+ os << " -T --num_thread_pairs_per_queue: Number of thread pairs per queue
["
<< TestParameters::_s_defaultNumThreadPairsPerQueue <<
"]" << std::endl;
- std::cout << " -E --enq_txn_blk_size: Enqueue transaction block
size (0=non-txn) ["
+ os << " -E --enq_txn_blk_size: Enqueue transaction block size
(0=non-txn) ["
<< TestParameters::_s_defaultEnqTxnBlkSize << "]"
<< std::endl;
- std::cout << " -D --deq_txn_blk_size: Dequeue transaction block
size (0=non-txn) ["
+ os << " -D --deq_txn_blk_size: Dequeue transaction block size
(0=non-txn) ["
<< TestParameters::_s_defaultDeqTxnBlkSize << "]"
<< std::endl;
- std::cout << std::endl;
- std::cout << "Store params:" << std::endl;
+ os << std::endl;
+ os << "Store params:" << std::endl;
#ifdef JOURNAL2
- std::cout << " -d --jrnl_dir: Store directory
[\""
+ os << " -d --jrnl_dir: Store directory [\""
<< mrg::journal2::JournalParameters::_s_defaultJrnlDir <<
"\"]" << std::endl;
- std::cout << " -b --jrnl_base_filename: Base name for journal
files [\""
+ os << " -b --jrnl_base_filename: Base name for journal files
[\""
<< mrg::journal2::JournalParameters::_s_defaultJrnlBaseFileName
<< "\"]" << std::endl;
- std::cout << " -f --num_jfiles: Number of journal files
["
+ os << " -f --num_jfiles: Number of journal files ["
<< mrg::journal2::JournalParameters::_s_defaultNumJrnlFiles <<
"]" << std::endl;
- std::cout << " -s --jfsize_sblks: Size of each journal file
in sblks (512 byte blocks) ["
+ os << " -s --jfsize_sblks: Size of each journal file in
sblks (512 byte blocks) ["
<< mrg::journal2::JournalParameters::_s_defaultJrnlFileSize_sblks
<< "]" << std::endl;
- std::cout << " -a --auto_expand: Auto-expand the journal
["
+ os << " -a --auto_expand: Auto-expand the journal ["
<<
(mrg::journal2::JournalParameters::_s_defaultAutoExpand?"T":"F")
<< "]" << std::endl;
- std::cout << " -e --ae_max_jfiles: Upper limit on number of
auto-expanded journal files ["
+ os << " -e --ae_max_jfiles: Upper limit on number of
auto-expanded journal files ["
<< mrg::journal2::JournalParameters::_s_defaultAutoExpandMaxJrnlFiles
<< "]" << std::endl;
- std::cout << " -p --wcache_num_pages: Number of write buffer
pages ["
+ os << " -p --wcache_num_pages: Number of write buffer pages
["
<< mrg::journal2::JournalParameters::_s_defaultWriteBuffNumPgs
<< "]" << std::endl;
- std::cout << " -c --wcache_pgsize_sblks: Size of each write buffer
page in sblks (512 byte blocks) ["
+ os << " -c --wcache_pgsize_sblks: Size of each write buffer page in
sblks (512 byte blocks) ["
<< mrg::journal2::JournalParameters::_s_defaultWriteBuffPgSize_sblks
<< "]" << std::endl;
#else
- std::cout << " -d --jrnl_dir: Store directory
[\""
+ os << " -d --jrnl_dir: Store directory [\""
<< JournalParameters::_s_defaultJrnlDir << "\"]"
<< std::endl;
- std::cout << " -b --jrnl_base_filename: Base name for journal
files [\""
+ os << " -b --jrnl_base_filename: Base name for journal files
[\""
<< JournalParameters::_s_defaultJrnlBaseFileName <<
"\"]" << std::endl;
- std::cout << " -f --num_jfiles: Number of journal files
["
+ os << " -f --num_jfiles: Number of journal files ["
<< JournalParameters::_s_defaultNumJrnlFiles << "]"
<< std::endl;
- std::cout << " -s --jfsize_sblks: Size of each journal file
in sblks (512 byte blocks) ["
+ os << " -s --jfsize_sblks: Size of each journal file in
sblks (512 byte blocks) ["
<< JournalParameters::_s_defaultJrnlFileSize_sblks <<
"]" << std::endl;
- std::cout << " -a --auto_expand: Auto-expand the journal
["
+ os << " -a --auto_expand: Auto-expand the journal ["
<<
(JournalParameters::_s_defaultAutoExpand?"T":"F") <<
"]" << std::endl;
- std::cout << " -e --ae_max_jfiles: Upper limit on number of
auto-expanded journal files ["
+ os << " -e --ae_max_jfiles: Upper limit on number of
auto-expanded journal files ["
<< JournalParameters::_s_defaultAutoExpandMaxJrnlFiles <<
"]" << std::endl;
- std::cout << " -p --wcache_num_pages: Number of write buffer
pages ["
+ os << " -p --wcache_num_pages: Number of write buffer pages
["
<< JournalParameters::_s_defaultWriteBuffNumPgs <<
"]" << std::endl;
- std::cout << " -c --wcache_pgsize_sblks: Size of each write buffer
page in sblks (512 byte blocks) ["
+ os << " -c --wcache_pgsize_sblks: Size of each write buffer page in
sblks (512 byte blocks) ["
<< JournalParameters::_s_defaultWriteBuffPgSize_sblks <<
"]" << std::endl;
#endif
}
bool
#ifdef JOURNAL2
-read_args(int argc, char** argv, mrg::test::TestParameters& tp,
mrg::journal2::JournalParameters& sp)
+readArgs(int argc, char** argv, TestParameters& tp,
mrg::journal2::JournalParameters& sp)
#else
-read_args(int argc, char** argv, mrg::test::TestParameters& tp,
mrg::test::JournalParameters& sp)
+readArgs(int argc, char** argv, TestParameters& tp, JournalParameters& sp)
#endif
{
static struct option long_options[] = {
@@ -286,13 +286,13 @@
case 'h':
default:
err = true;
- print_args();
+ printArgs();
}
}
return err;
}
-} // namespace test
+} // namespace jtest
} // namespace mrg
// -----------------------------------------------------------------
@@ -300,16 +300,16 @@
int
main(int argc, char** argv)
{
- mrg::test::TestParameters tp;
+ mrg::jtest::TestParameters tp;
#ifdef JOURNAL2
mrg::journal2::JournalParameters jp;
#else
- mrg::test::JournalParameters jp;
+ mrg::jtest::JournalParameters jp;
#endif
- if (mrg::test::read_args(argc, argv, tp, jp)) return 1;
- std::cout << tp.to_string() << std::endl;
- std::cout << jp.to_string() << std::endl;
- mrg::test::StorePerformanceTest p(tp, jp);
+ if (mrg::jtest::readArgs(argc, argv, tp, jp)) return 1;
+ std::cout << tp.toString() << std::endl;
+ std::cout << jp.toString() << std::endl;
+ mrg::jtest::StorePerformanceTest p(tp, jp);
p.run();
return 0;
Modified: store/trunk/cpp/perf/StorePerformanceTest.hpp
===================================================================
--- store/trunk/cpp/perf/StorePerformanceTest.hpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/StorePerformanceTest.hpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -29,9 +29,10 @@
* The GNU Lesser General Public License is available in the file COPYING.
*/
-#ifndef mrg_test_StorePerformanceTest_hpp
-#define mrg_test_StorePerformanceTest_hpp
+#ifndef mrg_jtest_StorePerformanceTest_hpp
+#define mrg_jtest_StorePerformanceTest_hpp
+#include <iostream>
#include <vector>
#include "JournalInstance.hpp"
@@ -47,38 +48,93 @@
namespace mrg
{
-namespace test
+namespace jtest
{
+ /**
+ * \brief Main test class; Create an instance and execute run()
+ *
+ * Main test class which aggregates the components of a test.
+ */
class StorePerformanceTest
{
- const TestParameters& _test_params;
+ const TestParameters& _testParams; ///< Ref to a struct
containing test params
#ifdef JOURNAL2
- const mrg::journal2::JournalParameters& _store_params;
+ const mrg::journal2::JournalParameters& _jrnlParams; ///< Ref to a struct
containing the journal parameters
#else
- const JournalParameters& _store_params;
+ const JournalParameters& _jrnlParams; ///< Ref to a struct
containing the journal parameters
#endif
- const char* _msg_data;
- std::vector<JournalInstance*> _tests;
- void _prepare_journals();
+ const char* msgData; ///< Pointer to msg data, which is
the same for all messages
+ std::vector<JournalInstance*> _jrnlList; ///< List of journals
(JournalInstance instances) being tested
+
+ /**
+ * \brief Creates journals and JournalInstance classes for all journals (queues)
to be tested
+ *
+ * Creates a new journal instance and JournalInstance instance for each queue.
The journals are initialized
+ * which creates a new set of journal files on the local storage media (which is
determined by path in
+ * JournalParameters._jrnlDir). This activity is not timed, and is not a part of
the performance test per se.
+ */
+ void _prepareJournals();
+
public:
+ /**
+ * \brief Constructor
+ *
+ * Constructor.
+ *
+ * \param tp Test parameters for the test
+ * \param jp Journal parameters for all queues (journals) in the test
+ */
#ifdef JOURNAL2
- StorePerformanceTest(const TestParameters& tp, const
mrg::journal2::JournalParameters& sp);
+ StorePerformanceTest(const TestParameters& tp, const
mrg::journal2::JournalParameters& jp);
#else
- StorePerformanceTest(const TestParameters& tp, const JournalParameters&
sp);
+ StorePerformanceTest(const TestParameters& tp, const JournalParameters&
jp);
#endif
+
+ /**
+ * \brief Destructor
+ *
+ * Destructor.
+ */
~StorePerformanceTest();
+
+ /**
+ * \brief Runs the test and prints out the results.
+ *
+ * Runs the test as set by the test parameters and journal parameters.
+ */
void run();
};
- void print_args();
+ /**
+ * \brief Print out the program arguments
+ *
+ * Print out the arguments to the performance program if requested by help or a
parameter error.
+ *
+ * \param os Stream to which the arguments should be streamed.
+ */
+ void printArgs(std::ostream& os = std::cout);
+
+ /**
+ * \brief Process the command-line arguments
+ *
+ * Process the command-line arguments and populate the TestParameters and
JournalParameters structs. Only the
+ * arguments supplied are on the command-line are changed in these structs, the
others remain unchanged. It is
+ * important therefore to make sure that defaults are pre-loaded (the default
behavior of the default constructors
+ * for these structs).
+ *
+ * \param argc Number of command-line arguments. Process directly from main().
+ * \param argv Pointer to array of command-line argument pointers. Process directly
from main().
+ * \param tp Reference to test parameter object. Only params on the command-line are
changed.
+ * \param jp Reference to journal parameter object. Only params on the command-line
are changed.
+ */
#ifdef JOURNAL2
- bool read_args(int argc, char** argv, mrg::test::TestParameters& tp,
mrg::journal2::JournalParameters& sp);
+ bool readArgs(int argc, char** argv, TestParameters& tp,
mrg::journal2::JournalParameters& jp);
#else
- bool read_args(int argc, char** argv, mrg::test::TestParameters& tp,
mrg::test::JournalParameters& sp);
+ bool readArgs(int argc, char** argv, TestParameters& tp, JournalParameters&
jp);
#endif
-} // namespace test
+} // namespace jtest
} // namespace mrg
-#endif // mrg_test_StorePerformanceTest_hpp
+#endif // mrg_jtest_StorePerformanceTest_hpp
Modified: store/trunk/cpp/perf/TestParameters.cpp
===================================================================
--- store/trunk/cpp/perf/TestParameters.cpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/TestParameters.cpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -35,7 +35,7 @@
namespace mrg
{
-namespace test
+namespace jtest
{
// static declarations
@@ -78,19 +78,25 @@
_deqTxnBlockSize(tp._deqTxnBlockSize)
{}
+void
+TestParameters::toStream(std::ostream& os)
+{
+ os << "Test Parameters:" << std::endl;
+ os << " num_msgs = " << _numMsgs << std::endl;
+ os << " msg_size = " << _msgSize << std::endl;
+ os << " num_queues = " << _numQueues << std::endl;
+ os << " num_thread_pairs_per_queue = " <<
_numThreadPairsPerQueue << std::endl;
+ os << " enq_txn_blk_size = " << _enqTxnBlockSize <<
std::endl;
+ os << " deq_txn_blk_size = " << _deqTxnBlockSize <<
std::endl;
+}
+
std::string
-TestParameters::to_string()
+TestParameters::toString()
{
std::ostringstream oss;
- oss << "Test Parameters:" << std::endl;
- oss << " num_msgs = " << _numMsgs << std::endl;
- oss << " msg_size = " << _msgSize << std::endl;
- oss << " num_queues = " << _numQueues << std::endl;
- oss << " num_thread_pairs_per_queue = " <<
_numThreadPairsPerQueue << std::endl;
- oss << " enq_txn_blk_size = " << _enqTxnBlockSize <<
std::endl;
- oss << " deq_txn_blk_size = " << _deqTxnBlockSize <<
std::endl;
+ toStream(oss);
return oss.str();
}
-} // namespace test
+} // namespace jtest
} // namespace mrg
Modified: store/trunk/cpp/perf/TestParameters.hpp
===================================================================
--- store/trunk/cpp/perf/TestParameters.hpp 2010-12-06 20:34:52 UTC (rev 4427)
+++ store/trunk/cpp/perf/TestParameters.hpp 2010-12-07 17:01:24 UTC (rev 4428)
@@ -29,15 +29,16 @@
* The GNU Lesser General Public License is available in the file COPYING.
*/
-#ifndef mrg_test_TestParameters_hpp
-#define mrg_test_TestParameters_hpp
+#ifndef mrg_jtest_TestParameters_hpp
+#define mrg_jtest_TestParameters_hpp
#include <cstdint>
+#include <iostream>
#include <string>
namespace mrg
{
-namespace test
+namespace jtest
{
/**
@@ -49,15 +50,15 @@
struct TestParameters
{
static uint32_t _s_defaultNumMsgs; ///< Default number of
messages to be sent
- static uint32_t _s_defaultMsgSize; ///< Default message size
- static uint16_t _s_defaultNumQueues; ///< Default number of
queues
+ static uint32_t _s_defaultMsgSize; ///< Default message size
in bytes
+ static uint16_t _s_defaultNumQueues; ///< Default number of
queues to test simultaneously
static uint16_t _s_defaultNumThreadPairsPerQueue; ///< Default number of
thread pairs (enq and deq) per queue
static uint16_t _s_defaultEnqTxnBlkSize; ///< Default transaction
block size for enqueues
static uint16_t _s_defaultDeqTxnBlkSize; ///< Default transaction
block size for dequeues
uint32_t _numMsgs; ///< Number of messages to
be sent
- uint32_t _msgSize; ///< Message size
- uint16_t _numQueues; ///< Number of queues
+ uint32_t _msgSize; ///< Message size in
bytes
+ uint16_t _numQueues; ///< Number of queues to
test simultaneously
uint16_t _numThreadPairsPerQueue; ///< Number of thread
pairs (enq and deq) per queue
uint16_t _enqTxnBlockSize; ///< Transaction block
size for enqueues
uint16_t _deqTxnBlockSize; ///< Transaction block
size for dequeues
@@ -73,6 +74,13 @@
* \brief Constructor
*
* Convenience constructor.
+ *
+ * \param numMsgs Number of messages to be sent
+ * \param msgSize Message size in bytes
+ * \param numQueues Number of queues to test simultaneously
+ * \param numThreadPairsPerQueue Number of thread pairs (enq and deq) per queue
+ * \param enqTxnBlockSize Transaction block size for enqueues
+ * \parma deqTxnBlockSize Transaction block size for dequeues
*/
TestParameters(const uint32_t numMsgs,
const uint32_t msgSize,
@@ -85,21 +93,33 @@
* \brief Copy constructor
*
* Copy constructor.
+ *
+ * \param tp Reference to TestParameters instance to be copied
*/
TestParameters(const TestParameters& tp);
+ /***
+ * \brief Stream the test parameters to an output stream
+ *
+ * Convenience feature which streams a multi-line representation of all the test
parameters, one per line to an
+ * output stream.
+ *
+ * \param os Output stream to which the class data is to be streamed
+ */
+ void toStream(std::ostream& os = std::cout);
+
/**
* \brief Creates a string representation of the test parameters
*
- * Convenience feature which creates a multiline string representation of all the
parameters, one parameter per
- * line.
+ * Convenience feature which creates a multi-line string representation of all
the test parameters, one
+ * per line.
*
- * \return multiline string representation of all the parameters, one parameter
per line.
+ * \return multi-line string representation of all the parameters, one parameter
per line.
*/
- std::string to_string();
+ std::string toString();
};
-} // namespace test
+} // namespace jtest
} // namespace mrg
-#endif // mrg_test_TestParameters_hpp
+#endif // mrg_jtest_TestParameters_hpp