#58 Fixed iterations on simple test cases.

The update to v2.0.0 improved the way experiment values and units were
implemented.  However, there was an oversight in that if these more
complex features were not used, only a single iteration of the code
under test was executed.

Minor documentation updates were also performed.

Author: DigitalInBlue

experiments/DemoSimple/DemoSimple.cpp

@@ -21,35 +21,35 @@ std::uniform_int_distribution<int> UniformDistribution(0, 1024);
 ///
 /// Interestingly, taking the sin of a constant number here resulted in a 
 /// great deal of optimization in clang and gcc.
-BASELINE(DemoSimple, Baseline, 10, 1000000)
+BASELINE(DemoSimple, Baseline, 30, 1000000)
 {
-	celero::DoNotOptimizeAway(static_cast<float>(sin(UniformDistribution(RandomDevice))));
+	celero::DoNotOptimizeAway(static_cast<float>(sin(fmod(UniformDistribution(RandomDevice), 3.14159265))));
 }
 
-/// Run a test consisting of 1 sample of 710000 operations per measurement.
+/// Run a test consisting of 1 sample of 710000 iterations per measurement.
 /// There are not enough samples here to likely get a meaningful result.
 BENCHMARK(DemoSimple, Complex1, 1, 710000)
 {
 	celero::DoNotOptimizeAway(static_cast<float>(sin(fmod(UniformDistribution(RandomDevice), 3.14159265))));
 }
 
-/// Run a test consisting of 30 samples of 710000 operations per measurement.
+/// Run a test consisting of 30 samples of 710000 iterations per measurement.
 /// There are not enough samples here to get a reasonable measurement
 /// It should get a Basline number lower than the previous test.
 BENCHMARK(DemoSimple, Complex2, 30, 710000)
 {
 	celero::DoNotOptimizeAway(static_cast<float>(sin(fmod(UniformDistribution(RandomDevice), 3.14159265))));
 }
 
-/// Run a test consisting of 60 samples of 710000 operations per measurement.
+/// Run a test consisting of 60 samples of 710000 iterations per measurement.
 /// There are not enough samples here to get a reasonable measurement
 /// It should get a Basline number lower than the previous test.
 BENCHMARK(DemoSimple, Complex3, 60, 710000)
 {
 	celero::DoNotOptimizeAway(static_cast<float>(sin(fmod(UniformDistribution(RandomDevice), 3.14159265))));
 }
 
-/// Run a manual test consisting of 60 samples of 7100000 operations per measurement.
+/// Run a test consisting of 60 samples of 7100000 iterations per measurement.
 /// Samples here are much large and there are more of them.  Expect a better answer here.
 /*
 BENCHMARK(DemoSimple, Complex4, 600, 20000000)

experiments/DemoSimpleJUnit/DemoSimpleJUnit.cpp

@@ -12,7 +12,6 @@
 CELERO_MAIN
 
 /// Run an automatic baseline.  
-/// Celero will help make sure enough samples are taken to get a reasonable measurement
 /// In reality, all of the "Complex" cases take the same amount of time to run.
 /// The difference in the results is a product of measurement error.
 BASELINE(DemoSimple, Baseline, 1, 7100000)
@@ -27,15 +26,13 @@ BENCHMARK_TEST(DemoSimple, Complex1, 1, 7100000, 1.0)
 	celero::DoNotOptimizeAway(static_cast<float>(sin(fmod(rand(), 3.14159265))));
 }
 
-/// Run a manual test consisting of 1 sample of 7100000 operations per measurement.
-/// Celero will help make sure enough samples are taken to get a reasonable measurement
+/// Run a manual test consisting of 1 sample of 7100000 iterations per measurement.
 BENCHMARK_TEST(DemoSimple, Complex2, 1, 7100000, 3.71)
 {
 	celero::DoNotOptimizeAway(static_cast<float>(sin(fmod(rand(), 3.14159265))));
 }
 
-/// Run a manual test consisting of 60 samples of 7100000 operations per measurement.
-/// Celero will help make sure enough samples are taken to get a reasonable measurement
+/// Run a manual test consisting of 60 samples of 7100000 iterations per measurement.
 BENCHMARK_TEST(DemoSimple, Complex3, 60, 7100000, 5.0)
 {
 	celero::DoNotOptimizeAway(static_cast<float>(sin(fmod(rand(), 3.14159265))));

experiments/DemoTransform/DemoTransform.cpp

@@ -94,21 +94,31 @@ class DemoTransformFixture : public celero::TestFixture
 		int arraySize;
 };
 
+#include <iostream>
+
 // For a baseline, I'll chose Bubble Sort.
 BASELINE_F(DemoTransform, ForLoop, DemoTransformFixture, 30, 10000)
 {
+	static int iterationCount = 0;
 	for(int i = 0; i < this->arraySize; i++)
 	{
 		this->arrayOut[i] = this->arrayIn[i] * DemoTransformFixture::Multiple;
 	}
+	iterationCount++;
+	if(iterationCount%1000== 0)	std::cout << "Baseline " << iterationCount << std::endl;
+	
 }
 
 // BASELINE_FIXED_F(DemoTransform, FixedTime, DemoTransformFixture, 30, 10000, 100)
 // { }
 
 BENCHMARK_F(DemoTransform, StdTransform, DemoTransformFixture, 30, 10000)
 {
+	static int iterationCount = 0;
 	std::transform(this->arrayIn.begin(), this->arrayIn.end(), this->arrayOut.begin(), std::bind1st(std::multiplies<int>(), DemoTransformFixture::Multiple));
+
+	iterationCount++;
+	if(iterationCount%1000== 0)	std::cout << "Benchmark " << iterationCount << std::endl;
 }
 
 BENCHMARK_F(DemoTransform, StdTransformLambda, DemoTransformFixture, 30, 10000)

include/celero/Celero.h

@@ -20,16 +20,13 @@
 /// See the License for the specific language governing permissions and
 /// limitations under the License.
 ///
-/// Ideas from Nick Brunn's Hayai (https://github.com/nickbruun/hayai) were used and I likely owe him a beer.
-///
-/// Special thanks to the band "3" for providing the development soundtrack.
+/// Special thanks to the bands "3" and "Coheed and Cambria" for providing the development soundtrack.
 ///
 /// "Iterations" refers to how many loops of the test function are measured as a time.
 /// For very fast code, many iterations would help amoratize measurement error.
 /// 
-/// "Samples" refers to how many sets of "Ops" will be performed.  Each "sample" is
-/// a single measurement.  Set to 0 to have Celero decide how many samples are required
-/// for a minimally significant answer.
+/// "Samples" refers to how many sets of "Iterations" will be performed.  Each "sample" is
+/// a single measurement.  
 ///
 /// It is highly encouraged to only run this code compiled in a "Release" mode to use all available optimizations.
 ///

include/celero/Result.h

@@ -81,23 +81,23 @@ namespace celero
 			uint64_t getRunTime() const;
 
 			///
-			/// \brief	Get the number of computed microseconds per operation.
+			/// \brief	Get the number of computed microseconds per iteration (i.e. a single call to the code under test.)
 			///
-			///	An operation is defined as one operation of one run.
+			///	A call is defined as one iteration of one execution of the code under test.
 			///
 			double getUsPerCall() const;
 
 			///
-			/// \brief	Get the number of computer operations per second.
+			/// \brief	Get the number of times the code under test could be called per second.
 			///
-			///	An operation is defined as one operation of one run.
+			///	A call is defined as one iteration of one execution of the code under test.
 			///
-			double getOpsPerSecond() const;
+			double getCallsPerSecond() const;
 
 			///
 			/// \brief	Get the processing speed in units per second.
 			///
-			///	An operation is defined as one operation of one run.
+			///	A call is defined as one iteration of one execution of the code under test.
 			///
 			double getUnitsPerSecond() const;
 

src/Experiment.cpp

@@ -286,7 +286,9 @@ size_t Experiment::getResultSize()
 {
 	if(this->pimpl->results.empty() == true)
 	{
-		this->pimpl->results.push_back(std::make_shared<Result>(this));
+		auto defaultResult = std::make_shared<Result>(this);
+		defaultResult->setProblemSpaceValue(0, 1.0, this->getIterations());
+		this->pimpl->results.push_back(defaultResult);
 	}
 
 	return this->pimpl->results.size();

src/Print.cpp

@@ -217,7 +217,7 @@ void celero::print::TableResult(std::shared_ptr<Result> x)
 
 	std::cout	<< PrintColumn(x->getBaselineMeasurement())
 				<< PrintColumn(x->getUsPerCall())
-				<< PrintColumn(x->getOpsPerSecond(), 2)
+				<< PrintColumn(x->getCallsPerSecond(), 2)
 				<< "\n";
 
 	celero::console::SetConsoleColor(celero::console::ConsoleColor_Default);

src/Result.cpp

@@ -126,7 +126,7 @@ double Result::getUsPerCall() const
 	return static_cast<double>(this->pimpl->stats.getMin()) / static_cast<double>(this->pimpl->problemSpaceIterations);
 }
 
-double Result::getOpsPerSecond() const
+double Result::getCallsPerSecond() const
 {
 	return 1.0 / (this->getUsPerCall() * 1.0e-6);
 }

src/ResultTable.cpp

@@ -101,7 +101,7 @@ void ResultTable::add(std::shared_ptr<Result> x)
 
 		this->pimpl->ofs << x->getBaselineMeasurement() << ","
 			<< x->getUsPerCall() << ","
-			<< x->getOpsPerSecond() << ","
+			<< x->getCallsPerSecond() << ","
 			<< x->getStatistics()->getMin() << ","
 			<< x->getStatistics()->getMean() << ","
 			<< x->getStatistics()->getMax() << ","

src/TestFixture.cpp

@@ -56,15 +56,16 @@ uint64_t TestFixture::run(const uint64_t, const uint64_t iterations, int64_t exp
 		// Set up the testing fixture.
 		this->setUp(experimentValue);
 
-		// Run the test body for each operation.
-		auto operation = iterations;
+		// Run the test body for each iterations.
+		auto iterationCounter = iterations;
 
 		// Get the starting time.
 		const auto startTime = celero::timer::GetSystemTime();
 
 		this->onExperimentStart(experimentValue);
 
-		while(operation--)
+		// Count down to zero
+		while(iterationCounter--)
 		{
 			this->UserBenchmark();
 		}

src/ThreadTestFixture.cpp

@@ -46,9 +46,9 @@ ThreadTestFixture::~ThreadTestFixture()
 {
 }
 
-void ThreadTestFixture::startThreads(uint64_t threads, uint64_t calls)
+void ThreadTestFixture::startThreads(uint64_t threads, uint64_t iterations)
 {
-	const uint64_t callsPerThread = calls / threads;
+	const uint64_t iterationsPerThread = iterations / threads;
 
 	for(uint64_t i = 0; i < threads; ++i)
 	{
@@ -57,12 +57,12 @@ void ThreadTestFixture::startThreads(uint64_t threads, uint64_t calls)
 			this->pimpl->futures.push_back(
 			//std::async(std::launch::deferred, 
 			std::async(std::launch::async, 
-				[this, i, callsPerThread]()
+				[this, i, iterationsPerThread]()
 				{
 					this->pimpl->currentThreadId = i + 1;
-					for(auto operation = size_t(0); operation < callsPerThread;)
+					for(auto threadIterationCounter = size_t(0); threadIterationCounter < iterationsPerThread;)
 					{
-						this->pimpl->currentCallId = ++operation;
+						this->pimpl->currentCallId = ++threadIterationCounter;
 						this->UserBenchmark();
 					}
 				}));

test/celero/Utilities.test.cpp

@@ -22,4 +22,4 @@
 TEST(celero_utilities, UsPerSec)
 {
 	EXPECT_EQ(1000000, celero::UsPerSec);
-}
+}