no message

TestApp1/TestApp1.cpp

@@ -9,98 +9,140 @@
 #include <DK.h>
 
 
-#define MAX_SIZE 200000000ULL
+#define MAX_SIZE 50000000ULL
 
-#ifdef _WIN32
-int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
-	_In_opt_ HINSTANCE hPrevInstance,
-	_In_ LPWSTR    lpCmdLine,
-	_In_ int       nCmdShow)
-#else
-int main(int argc, const char * argv[])
-#endif
+struct Value64
 {
-	union Value
+	int num;
+	int dummy[15];
+	bool operator < (const Value64& r) const
 	{
-		size_t i64;
-		struct
-		{
-			uint32_t h, l;
-		} i32;
-	};
+		return this->num < r.num;
+	}
+};
 
-	auto testStd = [](Value* val_copy, const Value* input, size_t len)->DKHashResultSHA1
+struct Value16
+{
+	int num;
+	int dummy[3];
+	bool operator < (const Value16& r) const
 	{
-		DKLogI("Copying buffer...");
-		memcpy(val_copy, input, sizeof(Value) * len);
+		return this->num < r.num;
+	}
+};
 
-		DKTimer timer;
-		DKThread::Sleep(1.0);
+union Value8
+{
+	size_t i64;
+	struct
+	{
+		uint32_t h, l;
+	} i32;
+	bool operator < (const Value8& r) const
+	{
+		return this->i64 < r.i64;
+	}
+};
+
+using Value4 = uint32_t;
+
+
+template <typename T, typename Rand>
+void DoTest(bool dkFirst, Rand&& r)
+{
+	T* val1 = new T[MAX_SIZE];
+	T* val2 = new T[MAX_SIZE];
+
+	DKLog("Generating data... (%s)", typeid(T).name());
+	for (size_t i = 0; i < MAX_SIZE; ++i)
+		val1[i] = val2[i] = r();
+
+	
+	DKThread::Sleep(0.2);
+
+	auto testSTL = [](T* val, size_t len)->DKHashResultSHA1
+	{
 		DKLogI("Sorting by std::sort...");
+		DKTimer timer;
 		timer.Reset();
-		std::sort(val_copy, val_copy + MAX_SIZE, [](const Value& lhs, const Value& rhs)->bool
+		std::sort(val, val + len, [](const auto& lhs, const auto& rhs)->bool
 		{
-			return lhs.i64 < rhs.i64;
+			return lhs < rhs;
 		});
 		double e1 = timer.Elapsed();
-
 		DKLogW("std::sort: %f", e1);
-		DKThread::Sleep(1.0);
-
-		return DKHashSHA1(val_copy, sizeof(Value)*len);
+		auto hash = DKHashSHA1(val, sizeof(T) * len);
+		DKLog("std::sort hash: %ls", (const wchar_t*)hash.String());
+		return hash;
 	};
-	auto testDK = [](Value* val_copy, const Value* input, size_t len)->DKHashResultSHA1
-	{
-		DKLogI("Copying buffer...");
-		memcpy(val_copy, input, sizeof(Value) * len);
 
-		DKStaticArray<Value> tmp(val_copy, MAX_SIZE);
-
-		DKTimer timer;
-		DKThread::Sleep(1.0);
+	auto testDK = [](T* val, size_t len)->DKHashResultSHA1
+	{
 		DKLogI("Sorting by DKStaticArray::Sort...");
+		DKStaticArray<T> tmp(val, len);
+		DKTimer timer;
 		timer.Reset();
-		tmp.Sort([](const Value& lhs, const Value& rhs)->bool
+		tmp.Sort([](const auto& lhs, const auto& rhs)->bool
 		{
-			return lhs.i64 < rhs.i64;
+			return lhs < rhs;
 		});
-		double e1 = timer.Elapsed();
-
-		DKLogW("DKStaticArray::sort: %f (memCopy:%d)", e1, tmp.SwapMethod);
-		DKThread::Sleep(1.0);
-
-		return DKHashSHA1(val_copy, sizeof(Value)*len);
+		double e2 = timer.Elapsed();
+		DKLogW("DKStaticArray::Sort: %f (SwapMethod:%d)", e2, tmp.SwapMethod);
+		auto hash = DKHashSHA1(val, sizeof(T) * len);
+		DKLog("DKStaticArray::Sort hash: %ls", (const wchar_t*)hash.String());
+		return hash;
 	};
 
-	DKApplication app;
-	Value* val1 = new Value[MAX_SIZE];
-
-	DKLog("Generating data...1");
-	for (size_t i = 0; i < MAX_SIZE; ++i)
+	if (dkFirst)
 	{
-		val1[i].i32 = { DKRandom(), DKRandom() };
+		auto hash1 = testDK(val1, MAX_SIZE);
+		auto hash2 = testSTL(val2, MAX_SIZE);
+		DKLog("Hash compare: %d", hash1.Compare(hash2));
 	}
-	Value* val_copy = new Value[MAX_SIZE];
-
-	auto doTest = [&]() {
-		DKHashResultSHA1 sha1_r1 = testDK(val_copy, val1, MAX_SIZE);
-		DKLogI("Hash1: %ls", (const wchar_t*)sha1_r1.String());
-		DKHashResultSHA1 sha1_r2 = testStd(val_copy, val1, MAX_SIZE);
-		DKLogI("Hash2: %ls", (const wchar_t*)sha1_r2.String());
-		DKLogI("Hash compare:%d", sha1_r1.Compare(sha1_r2));
-	};
-	doTest();
-
-	DKLog("Generating data...2");
-	for (size_t i = 0; i < MAX_SIZE; ++i)
+	else
 	{
-		val1[i].i32 = { DKRandom(), DKRandom() };
+		auto hash1 = testSTL(val1, MAX_SIZE);
+		auto hash2 = testDK(val2, MAX_SIZE);
+		DKLog("Hash compare: %d", hash1.Compare(hash2));
 	}
 
-	doTest();
-
 	delete[] val1;
-	delete[] val_copy;
+	delete[] val2;
+	DKLog("--------------");
+	DKThread::Sleep(0.2);
+}
+
+#ifdef _WIN32
+int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
+	_In_opt_ HINSTANCE hPrevInstance,
+	_In_ LPWSTR    lpCmdLine,
+	_In_ int       nCmdShow)
+#else
+int main(int argc, const char * argv[])
+#endif
+{
+	DKApplication app;
+
+	DoTest<Value64>(true, []()->Value64
+	{
+		Value64 val;
+		val.num = DKRandom();
+		return val;
+	});
+	DoTest<Value16>(true, []()->Value16
+	{
+		Value16 val;
+		val.num = DKRandom();
+		return val;
+	});
+	DoTest<Value8>(true, []()->Value8
+	{
+		return { size_t(DKRandom()) | (size_t(DKRandom()) << 32) };
+	});
+	DoTest<Value4>(true, []()->Value4
+	{
+		return DKRandom();
+	});
 
 	return 0;
 }