performance test for fast_trigonometry #265

readme.txt

@@ -79,6 +79,7 @@ Improvements:
 - Optimized bitfieldReverse and bitCount functions
 - Optimized matrix-vector multiple performance with Cuda #257, #258
 - Reduced integer type redifinitions #233
+- Rewrite of GTX_fast_trigonometry #264 #265
 
 Fixes:
 - Fixed std::nextafter not supported with C++11 on Android #217

test/gtx/gtx_fast_trigonometry.cpp

@@ -10,28 +10,151 @@
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/fast_trigonometry.hpp>
 #include <glm/gtc/constants.hpp>
+#include <ctime>
+#include <cstdio>
 
-int test_fastSin()
+namespace fastCos
 {
-	int Error(0);
-
-	float DiffMax = 0.0f;
-	for(std::size_t i = 0; i < 10000; ++i)
+	int perf()
 	{
-		float angle = glm::pi<float>() * 2.0f / static_cast<float>(i + 1);
-		float A = glm::sin(angle);
-		float B = glm::fastSin(angle);
-		DiffMax = glm::max(DiffMax, glm::abs(B - A));
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for(float i=begin; i<end; i = nextafterf(i, end))
+			result = glm::fastCos(i);
+		const std::clock_t timestamp2 = std::clock();
+		for(float i=begin; i<end; i = nextafterf(i, end))
+			result = glm::cos(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastCos Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("cos Time %d clocks\n", static_cast<unsigned int>(time_default));
+		return time_fast < time_default ? 0 : 1;
 	}
+}//namespace fastCos
 
-	return Error;
-}
+namespace fastSin
+{
+	int perf()
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::fastSin(i);
+		const std::clock_t timestamp2 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::sin(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastSin Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("sin Time %d clocks\n", static_cast<unsigned int>(time_default));
+		return time_fast < time_default ? 0 : 1;
+	}
+}//namespace fastSin
+
+namespace fastTan
+{
+	int perf()
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::fastTan(i);
+		const std::clock_t timestamp2 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::tan(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastTan Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("tan Time %d clocks\n", static_cast<unsigned int>(time_default));
+		return time_fast < time_default ? 0 : 1;
+	}
+}//namespace fastTan
+
+namespace fastAcos
+{
+	int perf()
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::fastAcos(i);
+		const std::clock_t timestamp2 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::acos(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastAcos Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("acos Time %d clocks\n", static_cast<unsigned int>(time_default));
+		return time_fast < time_default ? 0 : 1;
+	}
+}//namespace fastAcos
+
+namespace fastAsin
+{
+	int perf()
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::fastAsin(i);
+		const std::clock_t timestamp2 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::asin(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastAsin Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("asin Time %d clocks\n", static_cast<unsigned int>(time_default));
+		return time_fast < time_default ? 0 : 1;
+	}
+}//namespace fastAsin
+
+namespace fastAtan
+{
+	int perf()
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::fastAtan(i);
+		const std::clock_t timestamp2 = std::clock();
+		for (float i = begin; i<end; i = nextafterf(i, end))
+			result = glm::atan(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastAtan Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("atan Time %d clocks\n", static_cast<unsigned int>(time_default));
+		return time_fast < time_default ? 0 : 1;
+	}
+}//namespace fastAtan
 
 int main()
 {
 	int Error(0);
 
-	Error += test_fastSin();
+	Error += ::fastCos::perf();
+	Error += ::fastSin::perf();
+	Error += ::fastTan::perf();
+	Error += ::fastAcos::perf();
+	Error += ::fastAsin::perf();
+	Error += ::fastAtan::perf();
 
 	return Error;
 }