Merge remote-tracking branch 'Kernel/master'

2025-07-02 02:49:15 +00:00 · 2024-11-20 05:00:33 +02:00
parent 93d408e0af 19f2a78d35
commit 682c84b2af
468 changed files with 112800 additions and 1 deletions
--- a/Kernel/tests/stress.cpp
+++ b/Kernel/tests/stress.cpp
@ -0,0 +1,140 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifdef DEBUG
+
+#include "t.h"
+
+#include "../kernel.h"
+
+void killChildren(Tasking::PCB *pcb)
+{
+	if (pcb->Children.empty())
+	{
+		KPrint("Process %s(%d) has no children", pcb->Name, pcb->ID);
+		return;
+	}
+
+	std::vector<Tasking::PCB *> children = pcb->Children;
+
+	foreach (auto child in children)
+	{
+		if (child->State.load() == Tasking::Terminated)
+		{
+			KPrint("Process %s(%d) is already dead", child->Name, child->ID);
+			continue;
+		}
+
+		KPrint("Killing %s(%d)", child->Name, child->ID);
+		killChildren(child);
+		child->SetState(Tasking::Terminated);
+		debug("killed %s(%d)", child->Name, child->ID);
+	}
+}
+
+constexpr size_t chunk = 10 * 1024 * 1024; /* 10 MiB */
+std::atomic_size_t totalAllocated = 0;
+std::atomic_size_t highestScore = 0;
+std::atomic_bool halt_fork = false;
+std::vector<void *> allocatedChunks;
+Tasking::PCB *baseProc = nullptr;
+Tasking::PCB *lastProc = nullptr;
+std::atomic_bool hold = false;
+void StressKernel()
+{
+	return;
+
+	static int once = 0;
+	if (!once++)
+	{
+		debug("We have %d GiB of free memory",
+			  TO_GiB(KernelAllocator.GetFreeMemory()));
+		assert(TO_GiB(KernelAllocator.GetFreeMemory()) >= 1);
+	}
+
+	while (true)
+	{
+		while (hold.exchange(true, std::memory_order_acquire))
+			;
+
+		if (!halt_fork.load() && TaskManager->GetProcessList().size() > 100)
+			halt_fork.store(true);
+
+		void *ptr;
+		Tasking::PCB *pcb = nullptr;
+		if (TO_MiB(KernelAllocator.GetFreeMemory()) < 20)
+		{
+			KPrint("\x1b[1;31;41mNot enough memory left!");
+			goto End;
+		}
+
+		ptr = KernelAllocator.RequestPages(TO_PAGES(chunk));
+		if (ptr == nullptr)
+		{
+			KPrint("\x1b[1;31;41mFailed to allocate memory!");
+			KPrint("Score is: %d MiB (current is %d MiB)",
+				   TO_MiB(highestScore.load()), TO_MiB(totalAllocated.load()));
+			continue;
+		}
+		KPrint("Allocated %d bytes at %#lx", chunk, ptr);
+		allocatedChunks.push_back(ptr);
+		totalAllocated.fetch_add(chunk);
+		if (totalAllocated.load() > highestScore.load())
+			highestScore.store(totalAllocated.load());
+		KPrint("Total allocated: %d MiB [KERNEL: %d MiB free]",
+			   TO_MiB(totalAllocated.load()), TO_MiB(KernelAllocator.GetFreeMemory()));
+
+		if (lastProc == nullptr)
+			lastProc = thisProcess;
+
+		if (halt_fork.load() == false)
+		{
+			KPrint("Forking...");
+			pcb = TaskManager->CreateProcess(lastProc, "STRESS TEST", Tasking::Kernel);
+			lastProc = pcb;
+			if (baseProc == nullptr)
+				baseProc = pcb;
+			TaskManager->CreateThread(pcb, Tasking::IP(StressKernel));
+			KPrint("There are %d processes", TaskManager->GetProcessList().size());
+		}
+
+	End:
+		hold.store(true);
+		if (TO_GiB(totalAllocated.load()) >= 1)
+		{
+			KPrint("Freeing memory...");
+			forItr(itr, allocatedChunks)
+			{
+				KPrint("Freeing %#lx", *itr);
+				KernelAllocator.FreePages(*itr, TO_PAGES(chunk));
+				allocatedChunks.erase(itr);
+			}
+			totalAllocated.store(0);
+		}
+
+		// if (TaskManager->GetProcessList().size() >= 100)
+		// {
+		// 	KPrint("Killing processes...");
+		// 	killChildren(baseProc->Children.front());
+		// 	KPrint("All processes killed.");
+		// 	baseProc = nullptr;
+		// }
+		hold.store(false);
+	}
+}
+
+#endif // DEBUG