algorithm test

TestApp1/TestApp1.cpp

@@ -5,100 +5,87 @@
 #include "Win32/stdafx.h"
 #endif
 
+#include <algorithm>
 #include <DK.h>
 
-auto FormatBytes(size_t size, int maxDigits=3)->DKString
+#define MAX_SIZE 100000000ULL
+
+#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
 {
-	if (size > 1)
+	union Value
 	{
-		maxDigits = Clamp(maxDigits, 1, 4);
-
-		const char* suffixList[7] = { "Bytes","KB","MB","GB","TB","PB","EB" };
-		int suffixIndex = 0;
-		while (size >= 1024000 && suffixIndex < 6)
-		{
-			suffixIndex++;
-			size = size >> 10;
-		}
-		double s = static_cast<double>(size);
-		if (size >= 1000 && suffixIndex < 6)
-		{
-			s = s / 1024.0;
-			suffixIndex++;
-		}
-		if (suffixIndex > 0)
+		size_t i64;
+		struct
 		{
-			int numDigits = [](int s)->int
-			{
-				int n = 0;
-				while (s > 0)
-				{
-					n++;
-					s /= 10;
-				}
-				return Max(n, 1);
-			}(s);
-			return DKString::Format("%.*f %s", Clamp<int>(maxDigits - numDigits, 0, 3), s, suffixList[suffixIndex]);
-		}
-		return DKString::Format("%d %s", int(size), suffixList[0]);
-	}
-	return DKString::Format("%d Byte", int(size));
-};
+			uint32_t h, l;
+		} i32;
+	};
 
-class TestApp1 : public DKApplication
-{
-	DKObject<DKWindow> window;
-public:
-	void OnInitialize(void) override
+
+
+	auto testStd = [](Value* val_copy, const Value* input, size_t len)->DKHashResultSHA1
 	{
-		DKLogD("%s", DKGL_FUNCTION_NAME);
-		window = DKWindow::Create("DefaultWindow");
-		window->Activate();
+		DKLogI("Copying buffer...");
+		memcpy(val_copy, input, sizeof(Value) * len);
 
-		window->AddEventHandler(this,
-			DKFunction([this](const DKWindow::WindowEvent& e) {
-			if (e.type == DKWindow::WindowEvent::WindowClosed)
-				DKApplication::Instance()->Terminate(0);
-		}),
-			NULL, NULL);
+		DKTimer timer;
+		DKLogI("Sorting by std::sort...");
+		timer.Reset();
+		std::sort(val_copy, val_copy + MAX_SIZE, [](const Value& lhs, const Value& rhs)->bool
+		{
+			return lhs.i64 < rhs.i64;
+		});
+		double e1 = timer.Elapsed();
 
-	}
-	void OnTerminate(void) override
+		DKLogI("std::sort: %f", e1);
+		return DKHashSHA1(val_copy, sizeof(Value)*len);
+	};
+	auto testDK = [](Value* val_copy, const Value* input, size_t len)->DKHashResultSHA1
 	{
-		DKLogD("%s", DKGL_FUNCTION_NAME);
-		DKLogI("Memory Pool Statistics");
-		size_t numBuckets = DKMemoryPoolNumberOfBuckets();
-		DKMemoryPoolBucketStatus* buckets = new DKMemoryPoolBucketStatus[numBuckets];
-		DKMemoryPoolQueryAllocationStatus(buckets, numBuckets);
-		size_t usedBytes = 0;
-		for (int i = 0; i < numBuckets; ++i)
+		DKLogI("Copying buffer...");
+		memcpy(val_copy, input, sizeof(Value) * len);
+
+		DKStaticArray<Value> tmp(val_copy, MAX_SIZE);
+
+		DKTimer timer;
+		DKLogI("Sorting by DKStaticArray::Sort...");
+		timer.Reset();
+		tmp.Sort([](const Value& lhs, const Value& rhs)->bool
 		{
-			if (buckets[i].totalChunks > 0)
-			{
-				DKLogI("--> %lu: allocated:%lu, reserved:%ls. (usage:%.1f%%)",
-					buckets[i].chunkSize,
-					buckets[i].chunkSize * buckets[i].usedChunks,
-					(const wchar_t*)FormatBytes(buckets[i].chunkSize * (buckets[i].totalChunks - buckets[i].usedChunks)),
-					double(buckets[i].usedChunks) / double(buckets[i].totalChunks) * 100.0);
-				usedBytes += buckets[i].chunkSize * buckets[i].usedChunks;
-			}
-		}
-		DKLogI("MemoryPool Usage: %ls / %ls", (const wchar_t*)FormatBytes(usedBytes), (const wchar_t*)FormatBytes(DKMemoryPoolSize()));
-		delete[] buckets;
+			return lhs.i64 < rhs.i64;
+		});
+		double e1 = timer.Elapsed();
+
+		DKLogI("DKStaticArray::sort: %f (memCopy:%d)", e1, tmp.UseMemoryCopy);
+		return DKHashSHA1(val_copy, sizeof(Value)*len);
+	};
+
+	DKApplication app;
+	DKLog("Allocating buffer...");
+
+	Value* val1 = new Value[MAX_SIZE];
+
+	for (size_t i = 0; i < MAX_SIZE; ++i)
+	{
+		val1[i].i32 = { DKRandom(), DKRandom() };
 	}
-};
+	Value* val_copy = new Value[MAX_SIZE];
 
+	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));
 
-#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
-{
-	TestApp1 app;
-	DKPropertySet::SystemConfig().SetValue("AppDelegate", "AppDelegate");
-	return app.Run();
+	delete[] val1;
+	delete[] val_copy;
+
+	return 0;
 }