Add concurrency handling implementation with ticket management and file locking

cpp/src/Public/sweepstore/header.h

@@ -0,0 +1,143 @@
+#pragma once
+
+#include <iosfwd>
+
+#include "structures.h"
+#include "utils/file_handle.h"
+
+constexpr int roundToNearest16(int number) {
+    return (number + 15) & ~15;
+}
+
+class SweepstoreHeader {
+
+private:
+    SweepstoreFileHandle& file;
+
+public:
+    explicit SweepstoreHeader(SweepstoreFileHandle &fileStream) : file(fileStream) {}
+
+    // Offset 0 - 4 bytes
+    std::string readMagicNumber();
+    void writeMagicNumber(const std::string& magicNumber);
+
+    // Offset 4 - 12 bytes
+    std::string readVersion();
+    void writeVersion(const std::string& version);
+
+    // Offset 16 - 8 bytes
+    SweepstorePointer readAddressTablePointer();
+    void writeAddressTablePointer(const SweepstorePointer& ptr);
+
+    // Offset 24 - 4 bytes
+    uint32_t readFreeListCount();
+    void writeFreeListCount(uint32_t count);
+
+    // Offset 28 - 1 byte
+    bool readIsFreeListLifted();
+    void writeIsFreeListLifted(bool isLifted);
+
+    /**
+     * Initialises the header with default values.
+     */
+    void initialise();
+
+};
+
+constexpr int SWEEPSTORE_COMBINED_STATIC_HEADER_SIZE = roundToNearest16(46);
+
+struct SweepstoreWorkerTicketSnapshot {
+
+    SweepstoreWorkerTicketSnapshot() :
+        identifier(0),
+        workerHeartbeat(0),
+        state(SweepstoreTicketState::FREE),
+        operation(SweepstoreTicketOperation::NONE),
+        keyHash(0),
+        targetAddress(SweepstorePointer::NULL_PTR),
+        targetSize(0) {}
+
+    // Offset 0 - 4 bytes
+    uint32_t identifier;
+
+    // Offset 4 - 4 bytes
+    uint32_t workerHeartbeat;
+
+    // Offset 8 - 1 byte
+    SweepstoreTicketState state;
+
+    // Offset 9 - 1 byte
+    SweepstoreTicketOperation operation;
+
+    // Offset 10 - 8 bytes
+    uint64_t keyHash;
+
+    // Offset 18 - 8 bytes
+    SweepstorePointer targetAddress;
+
+    // Offset 26 - 4 bytes
+    uint32_t targetSize;
+};
+
+class SweepstoreWorkerTicket {
+
+    SweepstoreFileHandle& file;
+    uint32_t ticketIndex;
+
+    uint64_t getOffset() const {
+        return SWEEPSTORE_COMBINED_STATIC_HEADER_SIZE + (ticketIndex * TICKET_SIZE);
+    }
+
+public:
+    static constexpr int TICKET_SIZE = roundToNearest16(29);
+
+    SweepstoreWorkerTicket(const uint32_t index, SweepstoreFileHandle& fileStream) :
+        file(fileStream),
+        ticketIndex(index) {}
+
+    int getTicketIndex() const {
+        return ticketIndex;
+    }
+
+    void write(SweepstoreWorkerTicketSnapshot &snapshot);
+
+    bool writable();
+
+    SweepstoreWorkerTicketSnapshot snapshot();
+
+};
+
+class SweepstoreConcurrencyHeader {
+
+private:
+    SweepstoreFileHandle& file;
+
+public:
+    explicit SweepstoreConcurrencyHeader(SweepstoreFileHandle &fileStream) : file(fileStream) {}
+
+    // Offset 29 - 8 bytes
+    uint64_t readMasterIdentifier();
+    void writeMasterIdentifier(uint64_t identifier);
+
+    // Offset 37 - 4 bytes
+    uint32_t readMasterHeartbeat();
+    void writeMasterHeartbeat(uint32_t heartbeat);
+
+    // Offset 41 - 4 bytes
+    uint32_t readNumberOfWorkers();
+    void writeNumberOfWorkers(uint32_t numWorkers);
+
+    // Offset 45 - 1 byte
+    bool readIsReadAllowed();
+    void writeIsReadAllowed(bool isAllowed);
+
+    /**
+     * Initialises the concurrency header with default values.
+     */
+    void initialise(int concurrentWorkers);
+
+    SweepstoreWorkerTicket operator[](const uint32_t index) const {
+        return SweepstoreWorkerTicket(index, file);
+    }
+
+};