Queue testing

In the appfwk package, an executable called queue_IO_check exists which writes and reads integers to instances of classes which implement the appfwk's Queue interface class for testing purposes. It has several adjustable parameters, including the number of threads doing the writing, the number of threads doing the reading, the number of integers you want to write/read, and the type of queue you want to test.

To use it, you'll want to set up the appfwk environment as described here. queue_IO_check has several adjustable parameters which take on defaults, but for starters you can run it without arguments. If you're in the base of your development area you can just do the following:

./build/appfwk/test/queue_IO_check 

What this will do is take an empty instance of the StdDeQueue class, and have one thread writing (pushing) one million integers onto the queue with another thread reading (popping) them. When you're done, you'll see something like the following:

06-30 15:47:12.344986   TRACE nfo 1 thread(s) pushing 1000000 elements between them, each thread has an average time of 0 milliseconds between pushes
06-30 15:47:12.345063   TRACE nfo 1 thread(s) popping 1000000 elements between them, each thread has an average time of 0 milliseconds between pops
06-30 15:47:16.248345   TRACE nfo Max queue size during running was 106273
06-30 15:47:16.248367   TRACE nfo Final queue size at the end of running is 0
06-30 15:47:16.248373   TRACE nfo 1000000 push attempts made: 1000000 successful, 0 timeouts, 0 exception throws
06-30 15:47:16.248378   TRACE nfo 1000000 pop attempts made: 1000000 successful, 0 timeouts, 0 exception throws

In this particular instance, we see that the pushing/popping took just under four seconds, and that none of the calls timed out. Note that while the timeout is hardwired to 100 ms, this can be made an adjustable parameter in the future.

Optional arguments you'll find useful are the following:

--queue_type <type>

...where <type> can be FollySPSCQueue, FollyMPMCQueue, and StdDeQueue. These options will increase as new implementations of Queue become available.

--push_threads <# of threads>

...which is the number of threads pushing. Currently this must be >=1 (*), though in the case of FollySPSCQueue it can only be one.

--pop_threads <# of threads>

...which is the number of threads popping. This must be >=-0; setting this to 0 means simply that you just want to see how long it takes to push the elements onto the queue without additional threads removing the elements. In the case of FollySPSCQueue it can only be 0 or 1.

--nelements <# of elements>

This will specify the number of elements which get pushed/popped onto/off of the queue. Must be >=1.

(*) Although functionality will soon be added in which users can both specify that they want the queue to start off nonempty and that they want 0 pushing threads, in which case the program becomes a test solely of the popping functionality of the queue.