The_Bitburner_Scripts/Mizzajl/home/Ramses/S4controller.js

/*
Welcome to part 4. A continuous batcher is a major hurdle compared to everything we've done so far. The number
and complexity of the challenges increases drastically when trying to keep everything running indefinitely.
With luck, the overengineering we've done so far will have well prepared us for the challenges of a periodic
batcher.

Technically, I use quite a few JIT techniques in this batcher, but I don't consider it a true JIT batcher
as it doesn't take full advantage of the potential RAM efficiency. Instead, I favor simpler logic, while still
allowing the batcher to make certain adjustments if it needs to.

When it comes to continuous batchers, performance is king. We're going to aim for 5ms spacing as we have
throughout this guide so far, but there's a lot we need to do in those 5ms. As such, we need to make sure that
we choose which operations to do carefully, as well as when to do them and how to make sure they are as fast
as we can make them.
*/

// One new utility. A custom data structure for managing our schedule. You can see the details in utils.js
import { getServers, copyScripts, checkTarget, isPrepped, prep, Deque } from "/S4utils.js";

const TYPES = ["hack", "weaken1", "grow", "weaken2"];
const WORKERS = ["S4tHack.js", "S4tWeaken.js", "S4tGrow.js"];
const SCRIPTS = { hack: "S4tHack.js", weaken1: "S4tWeaken.js", grow: "S4tGrow.js", weaken2: "S4tWeaken.js" };
const COSTS = { hack: 1.7, weaken1: 1.75, grow: 1.75, weaken2: 1.75 };
// const OFFSETS = { hack: 0, weaken1: 1, grow: 2, weaken2: 3 };

// A new optional constant. The RamNet will attempt to reserve this much ram at home.
// You can set it to 0 if you don't want to reserve anything, and setting it too high will just reserve as much as possible.
const RESERVED_HOME_RAM = 0;

// A brand new class to help keep our increasingly complex logic organized.
class ContinuousBatcher {
	#ns; // The ns object. Stored as a class variable to save me the trouble of passing it all the time.

	// The usual data we've grown familiar with by now.
	#metrics;
	#ramNet;
	#target;
	#schedule;
	#dataPort;
	#batchCount = 0;
	#desyncs = 0; // This is mostly used for logging purposes, since the batcher is self-correcting.

	// A capital M Map. We'll use this to keep track of active jobs.
	#running = new Map();

	constructor(ns, metrics, ramNet) {
		this.#ns = ns;
		this.#metrics = metrics;
		this.#ramNet = ramNet;
		this.#target = metrics.target;
		this.#dataPort = ns.getPortHandle(ns.pid);

		// Seeding the first ending time.
		this.#metrics.end = Date.now() + metrics.wTime - metrics.spacer;

		// The new schedule I promised. It's a double-ended queue, but we'll mostly just be using it as a normal queue.
		// It has a static size, so we make sure it can accomodate all of our jobs.
		this.#schedule = new Deque(metrics.depth * 4);
	}

	// This is a function that can schedule a given number of batches.
	// With no arguments, it just fills up the queue.
	scheduleBatches(batches = this.#metrics.depth) {
		while (this.#schedule.size < batches * 4) {
			++this.#batchCount;
			for (const type of TYPES) {
				this.#metrics.end += this.#metrics.spacer;
				const job = new Job(type, this.#metrics, this.#batchCount);

				/*
				We don't actually error out if a job can't be assigned anymore. Instead, we just assign as much
				as we can. If it desyncs, the logic will correct it, and if a weaken2 gets cancelled then the actual
				depth will naturally decrease below the target depth. Not a perfect fix, but better than breaking.
				*/
				if (!this.#ramNet.assign(job)) {
					this.#ns.tprint(`WARN: Insufficient RAM to assign ${job.type}: ${job.batch}.`);
					continue;
				}
				this.#schedule.push(job);
			}
		}
	}

	// The function for deploying jobs. Very similar to the code from our shotgun batcher with some minor changes.
	async deploy() {
		// The for loop is replaced by a while loop, since our Deque isn't iterable.
		while (!this.#schedule.isEmpty()) {
			const job = this.#schedule.shift();
			job.end += this.#metrics.delay;
			const jobPid = this.#ns.exec(SCRIPTS[job.type], job.server, { threads: job.threads, temporary: true }, JSON.stringify(job));
			if (!jobPid) throw new Error(`Unable to deploy ${job.type}`);
			const tPort = this.#ns.getPortHandle(jobPid);

			// We save the pid for later.
			job.pid = jobPid;
			await tPort.nextWrite();

			// Jobs can be late as long as the delay won't cause collisions.
			this.#metrics.delay += Math.max(Math.ceil(tPort.read()) - this.#metrics.spacer, 0);
			this.#running.set(job.id, job);
		}

		// After the loop, we adjust future job ends to account for the delay, then discard it.
		this.#metrics.end += this.#metrics.delay;
		this.#metrics.delay = 0;
	}

	// Our old timeout function is now a proper function of its own. A few extra baubles in the log, but nothing exciting.
	/** @param {NS} ns */
	log() {
		const ns = this.#ns;
		const metrics = this.#metrics;
		const ramNet = this.#ramNet;
		ns.clearLog();
		ns.print(`Hacking ~\$${ns.formatNumber(metrics.maxMoney * metrics.greed * metrics.chance / (4 * metrics.spacer) * 1000)}/s from ${metrics.target}`);
		ns.print(`Status: ${isPrepped(ns, this.#target) ? "Prepped" : "Desynced"}`);
		ns.print(`Security: +${metrics.minSec - metrics.sec}`);
		ns.print(`Money: \$${ns.formatNumber(metrics.money, 2)}/${ns.formatNumber(metrics.maxMoney, 2)}`);
		ns.print(`Greed: ${Math.floor(metrics.greed * 1000) / 10}%`);
		ns.print(`Ram available: ${ns.formatRam(ramNet.totalRam)}/${ns.formatRam(ramNet.maxRam)}`);
		ns.print(`Active jobs: ${this.#running.size}/${metrics.depth * 4}`);

		// You'll see what this line's about in a moment.
		if (this.#desyncs) ns.print(`Hacks cancelled by desync: ${this.#desyncs}`);
	}

	// The core loop of our batcher logic. Quite lean with everything neatly divided into functions, but there's still
	// plenty going on here.
	async run() {
		// First we do some initial setup, this is essentially firing off a shotgun blast to get us started.
		const dataPort = this.#dataPort;
		this.scheduleBatches();
		await this.deploy();
		await this.#ns.sleep(0); // This is probably pointless. I forget why I put it here.
		this.log();
		while (true) {
			// Wait for the nextWrite, as usual.
			await dataPort.nextWrite();

			// Sometimes there's a delay and more than one job writes to the port at once.
			// We make sure to handle it all before we move on.
			while (!dataPort.empty()) {
				// Workers now report unique identifiers (type + batchnumber) used to find them on the map.
				const data = dataPort.read();

				// Free up the ram, them remove them from the active list.
				// The check handles a corner case where a hack gets "cancelled" after it's already finished.
				if (this.#running.has(data)) {
					this.#ramNet.finish(this.#running.get(data));
					this.#running.delete(data);
				}

				// If it's a W2, we've got an opening to do some work.
				if (data.startsWith("weaken2")) {
					// Recalculate times. Threads too, but only if prepped (the logic is in the function itself).
					this.#metrics.calculate(this.#ns);

					/*
					This is probably the most JIT-like aspect of the entire batcher. If the server isn't prepped, then
					we cancel the next hack to let the server fix itself. Between this and the extra 1% grow threads, level
					ups are completely handled. Rapid level ups can lead to a lot of lost jobs, but eventually the program
					stabilizes.

					There are probably more efficient ways to do this. Heck, even this solution could be optimized better,
					but for now, this is an adequate demonstration of a reasonable non-formulas solution to the level up
					problem. It also lets us dip our toes into JIT logic in preparation for the final part.
					*/
					if (!isPrepped(this.#ns, this.#target)) {
						const id = "hack" + (parseInt(data.slice(7)) + 1);
						const cancel = this.#running.get(id);
						// Just in case the hack was already aborted somehow.
						if (cancel) {
							this.#ramNet.finish(cancel);
							this.#ns.kill(cancel.pid);
							this.#running.delete(id);
							++this.#desyncs; // Just to keep track of how much we've lost keeping things prepped.
						}
					}

					// Then of course we just schedule and deploy a new batch.
					this.scheduleBatches(1);
					await this.deploy();
					this.log();
				}
			}
		}
	}
}

/*
	Our poor "main" function isn't much more than a kickstart for our new batcher object. It's a bit weird having
	it wedged between objects like this, but I wanted to have the new functionality up at the top since most of the
	remaining code hasn't changed much. I'll comment the changes anyway.
*/
/** @param {NS} ns */
export async function main(ns) {
	ns.disableLog("ALL");
	ns.tail();

	/*
	This commented out code is for a debugging tool that centralizes logs from the worker scripts into one place.
	It's main advantage is the ability to write txt logs to file, which can be perused later to track down errors.
	You can uncomment it if you'd like to see a live stream of workers finishing without flooding the terminal.

	If you do, make sure to search the file for -LOGGING and uncomment all relevant lines.
	*/
	// if (ns.isRunning("S4logHelper.js", "home")) ns.kill("S4logHelper.js", "home");
	// const logPort = ns.exec("S4logHelper.js", "home");
	// ns.atExit(() => ns.closeTail(logPort));

	// Setup is mostly the same.
	const dataPort = ns.getPortHandle(ns.pid);
	dataPort.clear();
	let target = ns.args[0] ? ns.args[0] : "n00dles";
	while (true) {
		const servers = getServers(ns, (server) => {
			if (!ns.args[0]) target = checkTarget(ns, server, target, ns.fileExists("Formulas.exe", "home"));
			copyScripts(ns, server, WORKERS, true);
			return ns.hasRootAccess(server);
		});
		const ramNet = new RamNet(ns, servers);
		const metrics = new Metrics(ns, target);
		// metrics.log = logPort; // Uncomment for -LOGGING.
		if (!isPrepped(ns, target)) await prep(ns, metrics, ramNet);
		ns.clearLog();
		ns.print("Optimizing. This may take a few seconds...");

		// Optimizer has changed again. Back to being synchronous, since the performance is much better.
		optimizePeriodic(ns, metrics, ramNet);
		metrics.calculate(ns);

		// Create and run our batcher.
		const batcher = new ContinuousBatcher(ns, metrics, ramNet);
		await batcher.run();

		/*
		You might be wondering why I put this in a while loop and then just return here. The simple answer is that
		it's because this is meant to be run in a loop, but I didn't implement the logic for it. This version of the
		batcher is completely static once created. It sticks to a single greed value, and doesn't update if more
		RAM becomes available.

		In a future version, you'd want some logic to allow the batcher to choose new targets, update its available RAM,
		and create new batchers during runtime. For now, that's outside the scope of this guide, but consider this loop
		as a sign of what could be.
		*/
		return;
	}
}

// The Job class, lean as it is, remains mostly unchanged. I got rid of the server argument since I wasn't using it
// and added a batch number instead.
class Job {
	constructor(type, metrics, batch) {
		this.type = type;
		// this.end = metrics.ends[type];
		this.end = metrics.end;
		this.time = metrics.times[type];
		this.target = metrics.target;
		this.threads = metrics.threads[type];
		this.cost = this.threads * COSTS[type];
		this.server = "none";
		this.report = true;
		this.port = metrics.port;
		this.batch = batch;

		// The future is now. The status and id are used for interacting with the Deque and Map in our batcher class.
		this.status = "active";
		this.id = type + batch;
		// this.log = metrics.log; // -LOGGING
	}
}

// The only change to the metrics class is the calculate function skipping threadcounts if the server isn't prepped.
/** @param {NS} ns */
class Metrics {
	constructor(ns, server) {
		this.target = server;
		this.maxMoney = ns.getServerMaxMoney(server);
		this.money = Math.max(ns.getServerMoneyAvailable(server), 1);
		this.minSec = ns.getServerMinSecurityLevel(server);
		this.sec = ns.getServerSecurityLevel(server);
		this.prepped = isPrepped(ns, server);
		this.chance = 0;
		this.wTime = 0;
		this.delay = 0;
		this.spacer = 5;
		this.greed = 0.01;
		this.depth = 0; // The number of concurrent batches to run. Set by the optimizer.

		this.times = { hack: 0, weaken1: 0, grow: 0, weaken2: 0 };
		this.end = 0; // Slight change for the new timing. The old way in commented out in case I switch back later.
		// this.ends = { hack: 0, weaken1: 0, grow: 0, weaken2: 0 };
		this.threads = { hack: 0, weaken1: 0, grow: 0, weaken2: 0 };

		this.port = ns.pid;
	}

	calculate(ns, greed = this.greed) {
		const server = this.target;
		const maxMoney = this.maxMoney;
		this.money = ns.getServerMoneyAvailable(server);
		this.sec = ns.getServerSecurityLevel(server);
		this.wTime = ns.getWeakenTime(server);
		this.times.weaken1 = this.wTime;
		this.times.weaken2 = this.wTime;
		this.times.hack = this.wTime / 4;
		this.times.grow = this.wTime * 0.8;
		// this.depth = this.wTime / this.spacer * 4;

		if (isPrepped(ns, server)) { // The only change.
			const hPercent = ns.hackAnalyze(server);
			const amount = maxMoney * greed;
			const hThreads = Math.max(Math.floor(ns.hackAnalyzeThreads(server, amount)), 1);
			const tGreed = hPercent * hThreads;
			const gThreads = Math.ceil(ns.growthAnalyze(server, maxMoney / (maxMoney - maxMoney * tGreed)) * 1.01);
			this.threads.weaken1 = Math.max(Math.ceil(hThreads * 0.002 / 0.05), 1);
			this.threads.weaken2 = Math.max(Math.ceil(gThreads * 0.004 / 0.05), 1);
			this.threads.hack = hThreads;
			this.threads.grow = gThreads;
			this.chance = ns.hackAnalyzeChance(server);
		}
	}
}

// A few minor edits here. An unused "simulation" mode, and reserved RAM on home.
/** @param {NS} ns */
class RamNet {
	#blocks = [];
	#minBlockSize = Infinity;
	#maxBlockSize = 0;
	#totalRam = 0;
	#prepThreads = 0;
	#maxRam = 0;
	#index = new Map();

	// Simulate mode ignores running scripts. Can be used to make calculations while the batcher is operating.
	constructor(ns, servers, simulate = false) {
		for (const server of servers) {
			if (ns.hasRootAccess(server)) {
				const maxRam = ns.getServerMaxRam(server);
				// Save some extra ram on home. Clamp used ram to maxRam to prevent negative numbers.
				const reserved = (server === "home") ? RESERVED_HOME_RAM : 0;
				const used = Math.min((simulate ? 0 : ns.getServerUsedRam(server)) + reserved, maxRam);
				const ram = maxRam - used;
				if (maxRam > 0) {
					const block = { server: server, ram: ram };
					this.#blocks.push(block);
					if (ram < this.#minBlockSize) this.#minBlockSize = ram;
					if (ram > this.#maxBlockSize) this.#maxBlockSize = ram;
					this.#totalRam += ram;
					this.#maxRam += maxRam;
					this.#prepThreads += Math.floor(ram / 1.75);
				}
			}
		}
		this.#sort();
		this.#blocks.forEach((block, index) => this.#index.set(block.server, index));
	}

	#sort() {
		this.#blocks.sort((x, y) => {
			if (x.server === "home") return 1;
			if (y.server === "home") return -1;

			return x.ram - y.ram;
		});
	}

	get totalRam() {
		return this.#totalRam;
	}

	get maxRam() {
		return this.#maxRam;
	}

	get maxBlockSize() {
		return this.#maxBlockSize;
	}

	get prepThreads() {
		return this.#prepThreads;
	}

	getBlock(server) {
		if (this.#index.has(server)) {
			return this.#blocks[this.#index.get(server)];
		} else {
			throw new Error(`Server ${server} not found in RamNet.`);
		}
	}

	assign(job) {
		const block = this.#blocks.find(block => block.ram >= job.cost);
		if (block) {
			job.server = block.server;
			block.ram -= job.cost;
			this.#totalRam -= job.cost;
			return true;
		} else return false;
	}

	finish(job) {
		const block = this.getBlock(job.server);
		block.ram += job.cost;
		this.#totalRam += job.cost;
	}

	cloneBlocks() {
		return this.#blocks.map(block => ({ ...block }));
	}

	printBlocks(ns) {
		for (const block of this.#blocks) ns.print(block);
	}

	testThreads(threadCosts) {
		const pRam = this.cloneBlocks();
		let batches = 0;
		let found = true;
		while (found) {
			for (const cost of threadCosts) {
				found = false;
				const block = pRam.find(block => block.ram >= cost);
				if (block) {
					block.ram -= cost;
					found = true;
				} else break;
			}
			if (found) batches++;
		}
		return batches;
	}
}

// Quite a bit has changed in this one. It's back to being synchronous, though it can still take a while.
/**
 * @param {NS} ns
 * @param {Metrics} metrics
 * @param {RamNet} ramNet
 */
function optimizePeriodic(ns, metrics, ramNet) {
	const maxThreads = ramNet.maxBlockSize / 1.75;
	const maxMoney = metrics.maxMoney;
	const hPercent = ns.hackAnalyze(metrics.target);
	const wTime = ns.getWeakenTime(metrics.target);

	const minGreed = 0.001;
	const maxSpacer = wTime; // This is more of an infinite loop safety net than anything.
	const stepValue = 0.01;
	let greed = 0.95; // Capping greed a bit lower. I don't have a compelling reason for this.
	let spacer = metrics.spacer; // We'll be adjusting the spacer in low ram conditions to allow smaller depths.

	while (greed > minGreed && spacer < maxSpacer) {
		// We calculate a max depth based on the spacer, then add one as a buffer.
		const depth = Math.ceil(wTime / (4 * spacer)) + 1;
		const amount = maxMoney * greed;
		const hThreads = Math.max(Math.floor(ns.hackAnalyzeThreads(metrics.target, amount)), 1);
		const tGreed = hPercent * hThreads;
		const gThreads = Math.ceil(ns.growthAnalyze(metrics.target, maxMoney / (maxMoney - maxMoney * tGreed)) * 1.01);
		if (Math.max(hThreads, gThreads) <= maxThreads) {
			const wThreads1 = Math.max(Math.ceil(hThreads * 0.002 / 0.05), 1);
			const wThreads2 = Math.max(Math.ceil(gThreads * 0.004 / 0.05), 1);

			const threadCosts = [hThreads * 1.7, wThreads1 * 1.75, gThreads * 1.75, wThreads2 * 1.75];

			// Glad I kept these, they turned out to be useful after all. When trying to hit target depth, 
			// checking that there's actually enough theoretical ram to fit them is a massive boost to performance.
			const totalCost = threadCosts.reduce((t, c) => t + c) * depth;
			if (totalCost < ramNet.totalRam) {
				// Double check that we can actually fit our threads into ram, then set our metrics and return.
				const batchCount = ramNet.testThreads(threadCosts);
				if (batchCount >= depth) {
					metrics.spacer = spacer;
					metrics.greed = greed;
					metrics.depth = depth;
					return
				}
			}
		}
		// await ns.sleep(0); // Uncomment and make the function async if you don't like the freeze on startup.

		// Decrement greed until we hit the minimum, then reset and increment spacer. We'll find a valid configuration eventually.
		greed -= stepValue;
		if (greed < minGreed && spacer < maxSpacer) {
			greed = 0.99;
			++spacer;
		}
	}
	throw new Error("Not enough ram to run even a single batch. Something has gone seriously wrong.");
}