DMAController.cpp

#include "DMAController.h"
#include <fstream>
#include <iostream>

using namespace std;

DMAController::DMAController() {
	isRunning = true;
	workerThread = thread(&DMAController::workerLoop, this);
}

void DMAController::stopThreads() {
	isRunning = false;
	conditionVar.notify_all();

	if (workerThread.joinable()) {
		workerThread.join();
	}

}

DMAController::~DMAController() {
	stopThreads();
}

void DMAController::scheduleWrite(string path, vector<char> data) {
	{
		lock_guard<mutex> lock(queueMutex);
		workQueue.push({ path, data });
	}

	conditionVar.notify_one();
}

void DMAController::workerLoop() {
	while (isRunning) {
		Request req;

		{
			// ensures only 1 worker uses queue at a time
			// => prevents workers from popping garbage memory from queue
			unique_lock<mutex> lock(queueMutex);

			// tells the thread to yield until there's work in the queue 
			// or manually told to be put be on yield again
			conditionVar.wait(lock, [this] {
				return !workQueue.empty() || !isRunning;
			});

			if (!isRunning && workQueue.empty()) return;

			// only one thread can run here at a time
			req = workQueue.front();
			workQueue.pop();
		}

		ofstream file(req.filepath, ios::binary | ios::app);
		if (file.is_open()) {
			file.write(req.data.data(), req.data.size());
		}
		else {
			cerr << "Error in DMA: " << req.filepath << endl;
		}

	}
}

void DMAController::waitForCompletion() {
	while (true) {
		unique_lock<mutex> lock(queueMutex);

		if (workQueue.empty()) {
			break;
		}

		lock.unlock();
		this_thread::sleep_for(chrono::milliseconds(10));
	}
}