xixasdev/SaveStateExample.cpp

## SaveStateExample.cpp
// SaveStateExample.cpp (C++11)
// AUTHOR: xixas | DATE: 2021.12.31 | LICENSE: WTFPL/PDM/CC0... your choice
// DESCRIPTION: Gaming: World-state snapshot example for non-interrupting saves.
// BUILD: g++ -o save-state-example SaveStateExample.cpp -lpthread -std=c++11

#include <cstdio> // printf
#include <atomic> // std::atomic
#include <mutex>  // std::mutex
#include <thread> // std::thread, std::this_thread
#include <chrono> // std::chrono

std::atomic<bool> isSaving(false); // Thread-safe save state flag

// Thread-safe generic type wrapper with snapshot capability.
// Temporarily allocates memory for a second value if updated during save.
template <typename T> class Saveable {
protected:
    mutable T *a, *b;
    mutable std::mutex mtx;

public:
    Saveable() { a = b = new T; }
    Saveable(const T& t) : Saveable() { *a = t; }
    Saveable(const Saveable<T>& o) : Saveable() { *a = *(o.a); if (o.a != o.b) { b = new T; *b = *(o.b); }}
    ~Saveable() { if (a != b) { delete a; } delete b; }

    Saveable<T>& operator=(const T& t) { setValue(t); return *this; } // Direct assignment
    operator T() { return getValue(); }                               // Direct use as type
    T operator +() { return getSaveValue(); }                         // Retrieve save value with a '+' prefix

    void setValue(const T& t) {
        std::lock_guard<std::mutex> lock(mtx);
        if (isSaving) {
            if (a == b) { b = new T; }
        } else {
            if (a != b) { delete a; a = b; }
        }
        *b = t;
    }

    T getValue() const {
        std::lock_guard<std::mutex> lock(mtx);
        if (a != b && !isSaving) { delete a; a = b; }
        return *b;
    }

    T getSaveValue() const {
        std::lock_guard<std::mutex> lock(mtx);
        if (a != b && !isSaving) { delete a; a = b; }
        return *a;
    }
};
typedef Saveable<bool>  bool_s;
typedef Saveable<int>   int_s;
typedef Saveable<float> float_s;

//-[ Example ]----------------------------------------------------------------
const size_t threadCount = 4, maxSet = 25, saveEvery = 4;
std::mutex   mtx;
bool_s       worldBool  = false;
int_s        worldInt   = 0;
float_s      worldFloat = 0.0f;

void thread(int id, bool canInitSave, bool canPerformSave) {
    do {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));

        // Lock and update world values
        mtx.lock();
        if (!isSaving || !canPerformSave) {
            if (worldInt >= maxSet) { mtx.unlock(); continue; }
            worldBool  = !worldBool;
            worldInt   = worldInt + 1;
            worldFloat = worldFloat + 0.5f;
        }
        const bool  b = worldBool,  b_ = +worldBool;
        const int   n = worldInt,   n_ = +worldInt;
        const float f = worldFloat, f_ = +worldFloat;
        bool initSave = canInitSave && !isSaving && n && !(n % saveEvery);
        int state = !isSaving ? 1 : !canPerformSave ? 2 : (isSaving = false);
        if (initSave) { isSaving = true; }
        mtx.unlock();

        // Display thread status and world state
        switch (state) {
            case 1:  printf("Thread %d: Active: [%d, %d, %.1f]\n", id, b, n, f); break;
            case 2:  printf("Thread %d: Active: [%d, %d, %.1f] -> Snapshot: [%d, %d, %.1f]\n", id, b, n, f, b_, n_, f_); break;
            default: printf("Thread %d: Save Complete... [%d, %d, %.1f]\n", id, b_, n_, f_); break;
        }
        if (initSave) { printf("Thread %d: Saving...\n", id); }
    } while (worldInt < maxSet || (isSaving && canPerformSave));
};

int main() {
    // Spawn threads
    std::thread threads[threadCount];
    for (size_t i = 0; i < threadCount; ++i) { threads[i] = std::thread(thread, i+1, true, i+1 == threadCount); }
    for (size_t i = 0; i < threadCount; ++i) { threads[i].join(); }
    return 0;
}
	// SaveStateExample.cpp (C++11)
	// AUTHOR: xixas \| DATE: 2021.12.31 \| LICENSE: WTFPL/PDM/CC0... your choice
	// DESCRIPTION: Gaming: World-state snapshot example for non-interrupting saves.
	// BUILD: g++ -o save-state-example SaveStateExample.cpp -lpthread -std=c++11

	#include <cstdio> // printf
	#include <atomic> // std::atomic
	#include <mutex> // std::mutex
	#include <thread> // std::thread, std::this_thread
	#include <chrono> // std::chrono

	std::atomic<bool> isSaving(false); // Thread-safe save state flag

	// Thread-safe generic type wrapper with snapshot capability.
	// Temporarily allocates memory for a second value if updated during save.
	template <typename T> class Saveable {
	protected:
	mutable T a, b;
	mutable std::mutex mtx;

	public:
	Saveable() { a = b = new T; }
	Saveable(const T& t) : Saveable() { *a = t; }
	Saveable(const Saveable<T>& o) : Saveable() { a = (o.a); if (o.a != o.b) { b = new T; b = (o.b); }}
	~Saveable() { if (a != b) { delete a; } delete b; }

	Saveable<T>& operator=(const T& t) { setValue(t); return *this; } // Direct assignment
	operator T() { return getValue(); } // Direct use as type
	T operator +() { return getSaveValue(); } // Retrieve save value with a '+' prefix

	void setValue(const T& t) {
	std::lock_guard<std::mutex> lock(mtx);
	if (isSaving) {
	if (a == b) { b = new T; }
	} else {
	if (a != b) { delete a; a = b; }
	}
	*b = t;
	}

	T getValue() const {
	std::lock_guard<std::mutex> lock(mtx);
	if (a != b && !isSaving) { delete a; a = b; }
	return *b;
	}

	T getSaveValue() const {
	std::lock_guard<std::mutex> lock(mtx);
	if (a != b && !isSaving) { delete a; a = b; }
	return *a;
	}
	};
	typedef Saveable<bool> bool_s;
	typedef Saveable<int> int_s;
	typedef Saveable<float> float_s;

	//-[ Example ]----------------------------------------------------------------
	const size_t threadCount = 4, maxSet = 25, saveEvery = 4;
	std::mutex mtx;
	bool_s worldBool = false;
	int_s worldInt = 0;
	float_s worldFloat = 0.0f;

	void thread(int id, bool canInitSave, bool canPerformSave) {
	do {
	std::this_thread::sleep_for(std::chrono::milliseconds(1));

	// Lock and update world values
	mtx.lock();
	if (!isSaving \|\| !canPerformSave) {
	if (worldInt >= maxSet) { mtx.unlock(); continue; }
	worldBool = !worldBool;
	worldInt = worldInt + 1;
	worldFloat = worldFloat + 0.5f;
	}
	const bool b = worldBool, b_ = +worldBool;
	const int n = worldInt, n_ = +worldInt;
	const float f = worldFloat, f_ = +worldFloat;
	bool initSave = canInitSave && !isSaving && n && !(n % saveEvery);
	int state = !isSaving ? 1 : !canPerformSave ? 2 : (isSaving = false);
	if (initSave) { isSaving = true; }
	mtx.unlock();

	// Display thread status and world state
	switch (state) {
	case 1: printf("Thread %d: Active: [%d, %d, %.1f]\n", id, b, n, f); break;
	case 2: printf("Thread %d: Active: [%d, %d, %.1f] -> Snapshot: [%d, %d, %.1f]\n", id, b, n, f, b_, n_, f_); break;
	default: printf("Thread %d: Save Complete... [%d, %d, %.1f]\n", id, b_, n_, f_); break;
	}
	if (initSave) { printf("Thread %d: Saving...\n", id); }
	} while (worldInt < maxSet \|\| (isSaving && canPerformSave));
	};

	int main() {
	// Spawn threads
	std::thread threads[threadCount];
	for (size_t i = 0; i < threadCount; ++i) { threads[i] = std::thread(thread, i+1, true, i+1 == threadCount); }
	for (size_t i = 0; i < threadCount; ++i) { threads[i].join(); }
	return 0;
	}
Reason	Response
Don't know how	Scroll up.... now you do
Didn't think of it, so it's "not a good idea"	Typical developer - we do like our ideas best. Sad Panda. User experience comes first
There's too much data to snapshot it in real time	That's exactly what this code does, regardless of dataset size
We can't allot any more threads for performance reasons	If your saves are bringing your game to a dead stop, those threads aren't doing anything anyway... give an existing thread double duty or, better yet, use a thread pool
Didn't start that way, updating the system would be too much work	It's called refactoring and it's part of the job - often most of the job
Can't possibly find every type instance	That'll teach you not to have a global typedef file for your game - live and learn
The memory overhead of using all of those class instances instead of primitive types is prohibitive	No, it's really not
No, it really is!	Then write a generic singleton that holds a 2-step collection of primitive pointers
Our game's written in X language - it doesn't support pointers	Quick saves are the least of your problems