Namespace faabric::util

namespace util

Typedefs

using BeastHttpRequest = beast::http::request<beast::http::string_body>

using BeastHttpResponse = beast::http::response<beast::http::string_body>

typedef std::chrono::steady_clock::time_point TimePoint

typedef std::unique_lock<std::mutex> UniqueLock

typedef std::unique_lock<std::shared_mutex> FullLock

typedef std::shared_lock<std::shared_mutex> SharedLock

typedef std::unique_ptr<uint8_t[], std::function<void(uint8_t*)>> MemoryRegion

Enums

enum DeltaCommand

Values:

enumerator DELTACMD_TOTAL_SIZE

enumerator DELTACMD_ZSTD_COMPRESSED_COMMANDS

enumerator DELTACMD_DELTA_OVERWRITE

enumerator DELTACMD_DELTA_XOR

enumerator DELTACMD_END

enum SnapshotDataType

Defines the permitted datatypes for snapshot diffs. Each has a predefined length, except for the raw option which is used for generic streams of bytes.

Values:

enumerator Raw

enumerator Bool

enumerator Int

enumerator Long

enumerator Float

enumerator Double

enum SnapshotMergeOperation

Defines the operation to perform when merging the diff with the original snapshot.

WARNING: this enum forms part of the API with executing applications, so make sure they are updated accordingly when it’s changed.

Values:

enumerator Bytewise

enumerator Sum

enumerator Product

enumerator Subtract

enumerator Max

enumerator Min

enumerator Ignore

enumerator XOR

Functions

std::shared_ptr<faabric::BatchExecuteRequest> batchExecFactory()

std::shared_ptr<faabric::BatchExecuteRequest> batchExecFactory(const std::string &user, const std::string &function, int count = 1)

bool isBatchExecRequestValid(std::shared_ptr<faabric::BatchExecuteRequest> ber)

void updateBatchExecAppId(std::shared_ptr<faabric::BatchExecuteRequest> ber, int newAppId)

void updateBatchExecGroupId(std::shared_ptr<faabric::BatchExecuteRequest> ber, int newGroupId)

std::shared_ptr<faabric::BatchExecuteRequestStatus> batchExecStatusFactory(int32_t appId)

std::shared_ptr<faabric::BatchExecuteRequestStatus> batchExecStatusFactory(std::shared_ptr<faabric::BatchExecuteRequest> ber)

int getNumFinishedMessagesInBatch(std::shared_ptr<faabric::BatchExecuteRequestStatus> berStatus)

std::vector<uint8_t> stringToBytes(const std::string &str)

int bytesToInt(const std::vector<uint8_t> &bytes)

std::string bytesToString(const std::vector<uint8_t> &bytes)

std::string formatByteArrayToIntString(const std::vector<uint8_t> &bytes)

void trimTrailingZeros(std::vector<uint8_t> &vectorIn)

int safeCopyToBuffer(const std::vector<uint8_t> &dataIn, uint8_t *buffer, int bufferLen)

int safeCopyToBuffer(const uint8_t *dataIn, int dataLen, uint8_t *buffer, int bufferLen)

std::string byteArrayToHexString(const uint8_t *data, int dataSize)

std::vector<uint8_t> hexStringToByteArray(const std::string &hexString)

template<typename T> std::string intToHexString(T i)

template<class T> T unalignedRead(const uint8_t *bytes)

template<class T> void unalignedWrite(const T &value, uint8_t *destination)

template<class T> void appendBytesOf(std::vector<uint8_t> &container, T value)

template<class T> size_t readBytesOf(const std::vector<uint8_t> &container, size_t offset, T *outValue)

template<typename T> std::vector<uint8_t> valueToBytes(T val)

Clock &getGlobalClock()

template<typename T> bool compareArrays(T *v1, T *v2, int size)

SystemConfig &getSystemConfig()

void setUpCrashHandler(int sig = -1)

void handleCrash(int sig)

std::vector<uint8_t> serializeDelta(const DeltaSettings &cfg, const uint8_t *oldDataStart, size_t oldDataLen, const uint8_t *newDataStart, size_t newDataLen)

void applyDelta(const std::vector<uint8_t> &delta, std::function<void(uint32_t)> setDataSize, std::function<uint8_t*()> getDataPointer)

std::shared_ptr<DirtyTracker> getDirtyTracker(): Returns the dirty tracker singleton. The dirty tracking mode is determined in the system config.

void resetDirtyTracker(): Resets the dirty tracker singleton (e.g. if the config has been changed).

std::string getEnvVar(const std::string &key, const std::string &deflt)

std::string setEnvVar(const std::string &varName, const std::string &value)

void unsetEnvVar(const std::string &varName)

unsigned int getUsableCores()

ExecGraphNode getFunctionExecGraphNode(int appId, int msgId)

ExecGraph getFunctionExecGraph(const faabric::Message &msg)

void logChainedFunction(faabric::Message &parentMessage, const faabric::Message &chainedMessage)

std::set<unsigned int> getChainedFunctions(const faabric::Message &msg)

int countExecGraphNodes(const ExecGraph &graph)

std::set<std::string> getExecGraphHosts(const ExecGraph &graph)

std::vector<std::string> getMpiRankHostsFromExecGraph(const ExecGraph &graph)

std::pair<std::vector<std::string>, std::vector<std::string>> getMigratedMpiRankHostsFromExecGraph(const ExecGraph &graph)

std::string execNodeToJson(const ExecGraphNode &node)

std::string execGraphToJson(const ExecGraph &graph)

void addDetail(faabric::Message &msg, const std::string &key, const std::string &value)

void incrementCounter(faabric::Message &msg, const std::string &key, const int valueToIncrement = 1)

std::string readFileToString(const std::string &path)

std::vector<uint8_t> readFileToBytes(const std::string &path)

void writeBytesToFile(const std::string &path, const std::vector<uint8_t> &data)

bool isWasm(const std::vector<uint8_t> &bytes)

std::string funcToString(const faabric::Message &msg, bool includeId)

std::string funcToString(const std::shared_ptr<faabric::BatchExecuteRequest> &req)

unsigned int setMessageId(faabric::Message &msg)

std::string buildAsyncResponse(const faabric::Message &msg)

std::shared_ptr<faabric::Message> messageFactoryShared(const std::string &user, const std::string &function)

faabric::Message messageFactory(const std::string &user, const std::string &function)

std::string resultKeyFromMessageId(unsigned int mid)

std::string statusKeyFromMessageId(unsigned int mid)

std::vector<uint8_t> messageToBytes(const faabric::Message &msg)

std::vector<std::string> getArgvForMessage(const faabric::Message &msg)

std::string getMainThreadSnapshotKey(const faabric::Message &msg)

unsigned int generateGid()

std::unique_ptr<FaabricCpuSet> pinThreadToFreeCpu(pthread_t thread)

std::string messageToJson(const google::protobuf::Message &msg)

void jsonToMessage(const std::string &jsonStr, google::protobuf::Message *msg)

void initLogging()

inline void *malloc(std::size_t size)

inline void free(void *ptr)

inline void *realloc(void *ptr, std::size_t newSize)

void mergeManyDirtyPages(std::vector<char> &dest, const std::vector<std::vector<char>> &source)

void mergeDirtyPages(std::vector<char> &dest, const std::vector<char> &source)

bool isPageAligned(const void *ptr)

size_t getRequiredHostPages(size_t nBytes)

size_t getRequiredHostPagesRoundDown(size_t nBytes)

size_t alignOffsetDown(size_t offset)

AlignedChunk getPageAlignedChunk(long offset, long length)

MemoryRegion allocatePrivateMemory(size_t size)

MemoryRegion allocateSharedMemory(size_t size)

MemoryRegion allocateVirtualMemory(size_t size)

void claimVirtualMemory(std::span<uint8_t> region)

void mapMemoryPrivate(std::span<uint8_t> target, int fd)

void mapMemoryShared(std::span<uint8_t> target, int fd)

void resizeFd(int fd, size_t size)

void writeToFd(int fd, off_t offset, std::span<const uint8_t> data)

int createFd(size_t size, const std::string &fdLabel)

void appendDataToFd(int fd, std::span<uint8_t> data)

std::string getIPFromHostname(const std::string &hostname)

std::string getPrimaryIPForThisHost(const std::string &interface): Returns the IP for the given interface, or picks one based on an “appropriate” interface name.

faabric::PointToPointMappings ptpMappingsFromSchedulingDecision(std::shared_ptr<faabric::batch_scheduler::SchedulingDecision> decision)

std::string randomString(int len)

std::string randomStringFromSet(const std::unordered_set<std::string> &s)

void diffArrayRegions(std::vector<SnapshotDiff> &diffs, uint32_t startOffset, uint32_t endOffset, std::span<const uint8_t> a, std::span<const uint8_t> b)

template<typename T> inline bool calculateDiffValue(const uint8_t *original, uint8_t *updated, SnapshotMergeOperation operation)

template<typename T> inline T applyDiffValue(const uint8_t *original, const uint8_t *diff, SnapshotMergeOperation operation)

std::string snapshotDataTypeStr(SnapshotDataType dt)

std::string snapshotMergeOpStr(SnapshotMergeOperation op)

std::string keyForUser(const std::string &user, const std::string &key)

void maskDouble(unsigned int *maskArray, unsigned long idx)

bool isAllWhitespace(const std::string &input)

bool startsWith(const std::string &input, const std::string &subStr)

bool endsWith(const std::string &input, const std::string &subStr)

bool contains(const std::string &input, const std::string &subStr)

std::string removeSubstr(const std::string &input, const std::string &toErase)

bool stringIsInt(const std::string &input)

template<class T> std::string vectorToString(std::vector<T> vec)

void setTestMode(bool val)

void setMockMode(bool val)

bool isTestMode()

bool isMockMode()

faabric::util::TimePoint startTimer()

long getTimeDiffNanos(const faabric::util::TimePoint &begin)

long getTimeDiffMicros(const faabric::util::TimePoint &begin)

double getTimeDiffMillis(const faabric::util::TimePoint &begin)

void logEndTimer(const std::string &label, const faabric::util::TimePoint &begin)

void startGlobalTimer()

void printTimerTotals()

uint64_t timespecToNanos(struct timespec *nativeTimespec)

void nanosToTimespec(uint64_t nanos, struct timespec *nativeTimespec)

void *pageAlignAddress(void *faultAddr)

int countExecGraphNode(const ExecGraphNode &node)

std::set<std::string> getExecGraphHostsForNode(const ExecGraphNode &node)

std::vector<std::string> getMpiRankHostsFromExecGraphNode(const ExecGraphNode &node)

size_t writeDataCallback(void *ptr, size_t size, size_t nmemb, void *stream)

static std::unique_ptr<FaabricCpuSet> getNextFreeCpu()

static void doPinThreadToCpu(pthread_t thread, cpu_set_t *cpuSet)

MemoryRegion doAlloc(size_t size, int prot, int flags)

void mapMemory(std::span<uint8_t> target, int fd, int flags)

Variables

constexpr uint8_t DELTA_PROTOCOL_VERSION = 1

constexpr int DELTA_ZSTD_COMPRESS_LEVEL = 1

const int NO_CPU_IDX = -1

const int GHA_CPU_IDX = -2

static const long HOST_PAGE_SIZE = sysconf(_SC_PAGESIZE)

static thread_local DirtyTrackingRecord tracking

static ThreadSafeDirtyTrackingRecord globalTracking

static std::shared_ptr<DirtyTracker> tracker = nullptr

static long uffd = -1

static bool uffdWriteProtect = false

static bool uffdSigbus = false

static int closeFd = -1

static std::shared_ptr<std::jthread> eventThread = nullptr

static FreeCpus freeCpus

static std::unordered_map<std::string, std::string> ipMap

static std::mutex hostnameMx

static std::atomic<bool> testMode = false

static std::atomic<bool> mockMode = false

struct AlignedChunk

Public Members

long originalOffset = 0

long originalLength = 0

long nBytesOffset = 0

long nBytesLength = 0

long nPagesOffset = 0

long nPagesLength = 0

long offsetRemainder = 0

class Barrier

Public Functions

explicit Barrier(int countIn, std::function<void()> completionFunctionIn, int timeoutMsIn)

void wait()

Public Static Functions

static std::shared_ptr<Barrier> create(int count, std::function<void()> completionFunctionIn, int timeoutMs = DEFAULT_BARRIER_TIMEOUT_MS)

static std::shared_ptr<Barrier> create(int count, int timeoutMs = DEFAULT_BARRIER_TIMEOUT_MS)

class ChainedCallFailedException : public faabric::util::FaabricException

Public Functions

inline explicit ChainedCallFailedException(std::string message)

class Clock

Public Functions

Clock()

const TimePoint now()

long epochMillis()

long timeDiff(const TimePoint &t1, const TimePoint &t2)

long timeDiffNano(const TimePoint &t1, const TimePoint &t2)

long timeDiffMicro(const TimePoint &t1, const TimePoint &t2)

template<class Key, class Value> class ConcurrentMap

Public Types

using key_type = typename UnderlyingMap::key_type

using mapped_type = typename UnderlyingMap::value_type

using size_type = typename UnderlyingMap::size_type

using difference_type = typename UnderlyingMap::difference_type

Public Functions

ConcurrentMap() = default

inline ConcurrentMap(size_t initialCapacity)

ConcurrentMap(const ConcurrentMap&) = delete

ConcurrentMap &operator=(const ConcurrentMap&) = delete

ConcurrentMap(ConcurrentMap&&) = default

ConcurrentMap &operator=(ConcurrentMap&&) = default

inline void swap(ConcurrentMap<Key, Value> &other)

inline bool isEmpty() const

inline size_t size() const

inline size_t capacity() const

inline void reserve(size_t count)

inline void rehash(size_t count)

inline void clear()

template<class K = Key> inline bool erase(const KeyArg<K> &key)

template<class P = std::pair<Key, Value>> inline bool insert(P &&pair)

template<class K = Key> inline bool insertOrAssign(K &&key, Value &&value)

template<class K = Key, class ...Args> inline bool tryEmplace(K &&key, Args&&... args)

template<class K = Key, class ...Args> inline std::pair<bool, Value> tryEmplaceShared(K &&key, Args&&... args) requires detail

template<class K = Key, std::invocable<const Value&> F> inline bool inspect(const KeyArg<K> &key, F inspector) const

template<class K = Key> inline std::optional<Value> get(const KeyArg<K> &key) const requires std

template<std::predicate<const Key&, const Value&> F> inline void eraseIf(F predicate)

struct DeltaSettings

Public Functions

explicit DeltaSettings(const std::string &definition)

std::string toString() const

Public Members

bool usePages = true

size_t pageSize = 4096

bool xorWithOld = true

bool useZstd = true

int zstdLevel = 1

class DirtyTracker

Subclassed by faabric::util::NoneDirtyTracker, faabric::util::SegfaultDirtyTracker, faabric::util::SoftPTEDirtyTracker, faabric::util::UffdDirtyTracker

Public Functions

inline DirtyTracker(const std::string &modeIn)

virtual void clearAll() = 0

virtual std::string getType() = 0

virtual void startTracking(std::span<uint8_t> region) = 0

virtual void stopTracking(std::span<uint8_t> region) = 0

virtual std::vector<char> getDirtyPages(std::span<uint8_t> region) = 0

virtual void startThreadLocalTracking(std::span<uint8_t> region) = 0

virtual void stopThreadLocalTracking(std::span<uint8_t> region) = 0

virtual std::vector<char> getThreadLocalDirtyPages(std::span<uint8_t> region) = 0

virtual std::vector<char> getBothDirtyPages(std::span<uint8_t> region) = 0

class DirtyTrackingRecord

Wrapper around the actual bookkeeping behind dirty tracking. This is deliberately not thread-safe as it will only ever be used in TLS for signal handlers.

Subclassed by faabric::util::ThreadSafeDirtyTrackingRecord

Public Functions

DirtyTrackingRecord() = default

inline virtual void trackRegion(std::span<uint8_t> region)

inline virtual void markPage(void *addr)

inline virtual bool isInitialised()

inline virtual int getNPages()

inline virtual std::vector<char> getDirtyFlags()

inline virtual void reset()

struct ExecGraph

Public Members

ExecGraphNode rootNode

struct ExecGraphNode

Public Members

faabric::Message msg

std::vector<ExecGraphNode> children

class ExecGraphNodeNotFoundException : public faabric::util::FaabricException

Public Functions

inline explicit ExecGraphNodeNotFoundException(std::string message)

class FaabricCpuSet

Public Functions

FaabricCpuSet(int cpuIdxIn = NO_CPU_IDX)

FaabricCpuSet &operator=(const FaabricCpuSet&) = delete

FaabricCpuSet(const FaabricCpuSet&) = delete

~FaabricCpuSet()

inline cpu_set_t *get()

class FaabricException : public exception

Subclassed by faabric::executor::ChainedCallException, faabric::executor::ExecutorContextException, faabric::redis::RedisNoResponseException, faabric::transport::MessageTimeoutException, faabric::util::ChainedCallFailedException, faabric::util::ExecGraphNodeNotFoundException, faabric::util::FunctionFrozenException, faabric::util::FunctionMigratedException, faabric::util::JsonSerialisationException, faabric::util::QueueTimeoutException

Public Functions

inline explicit FaabricException(std::string message)

inline const char *what() const noexcept override

template<typename T> class FixedCapacityQueue

Public Functions

inline FixedCapacityQueue(int capacity)

inline FixedCapacityQueue()

inline void enqueue(T value, long timeoutMs = DEFAULT_QUEUE_TIMEOUT_MS)

inline void dequeueIfPresent(T *res)

inline T dequeue(long timeoutMs = DEFAULT_QUEUE_TIMEOUT_MS)

inline T *peek(long timeoutMs = DEFAULT_QUEUE_TIMEOUT_MS)

inline void drain(long timeoutMs = DEFAULT_QUEUE_TIMEOUT_MS)

inline long size()

inline void reset()

class FlagWaiter : public std::enable_shared_from_this<FlagWaiter>

Public Functions

FlagWaiter(int timeoutMsIn = DEFAULT_FLAG_WAIT_MS)

void waitOnFlag()

void setFlag(bool value)

class FreeCpus

Public Functions

inline FreeCpus()

Public Members

std::vector<std::unique_ptr<std::atomic<bool>>> cpuVec

class FunctionFrozenException : public faabric::util::FaabricException

Public Functions

inline explicit FunctionFrozenException(std::string message)

class FunctionMigratedException : public faabric::util::FaabricException

Public Functions

inline explicit FunctionMigratedException(std::string message)

class JsonSerialisationException : public faabric::util::FaabricException

Public Functions

inline explicit JsonSerialisationException(std::string message)

class Latch : public std::enable_shared_from_this<Latch>

Public Functions

explicit Latch(int countIn, int timeoutMsIn)

void wait()

Public Static Functions

static std::shared_ptr<Latch> create(int count, int timeoutMs = DEFAULT_LATCH_TIMEOUT_MS)

class NoneDirtyTracker : public faabric::util::DirtyTracker

Public Functions

NoneDirtyTracker(const std::string &modeIn)

virtual void clearAll() override

inline virtual std::string getType() override

virtual void startTracking(std::span<uint8_t> region) override

virtual void stopTracking(std::span<uint8_t> region) override

virtual std::vector<char> getDirtyPages(std::span<uint8_t> region) override

virtual void startThreadLocalTracking(std::span<uint8_t> region) override

virtual void stopThreadLocalTracking(std::span<uint8_t> region) override

virtual std::vector<char> getThreadLocalDirtyPages(std::span<uint8_t> region) override

virtual std::vector<char> getBothDirtyPages(std::span<uint8_t> region) override

class PeriodicBackgroundThread

#include <PeriodicBackgroundThread.h>

Wrapper around periodic background thread that repeatedly does some arbitrary work after a given interval.

Subclassed by faabric::planner::KeepAliveThread, faabric::scheduler::SchedulerReaperThread

Public Functions

void start(int intervalSecondsIn): Start the background thread with the given wake-up interval in seconds.

void stop(): Stop and wait for this thread to finish.

virtual void doWork() = 0

virtual void tidyUp()

inline int getIntervalSeconds()

template<typename T> class Queue

Public Functions

inline void enqueue(T value)

inline void dequeueIfPresent(T *res)

inline T dequeue(long timeoutMs = DEFAULT_QUEUE_TIMEOUT_MS)

inline T *peek(long timeoutMs = 0)

inline void waitToDrain(long timeoutMs)

inline void drain()

inline long size()

inline void reset()

class QueueTimeoutException : public faabric::util::FaabricException

Public Functions

inline explicit QueueTimeoutException(std::string message)

class SegfaultDirtyTracker : public faabric::util::DirtyTracker

Public Functions

SegfaultDirtyTracker(const std::string &modeIn)

virtual void clearAll() override

inline virtual std::string getType() override

virtual void startTracking(std::span<uint8_t> region) override

virtual void stopTracking(std::span<uint8_t> region) override

virtual std::vector<char> getDirtyPages(std::span<uint8_t> region) override

virtual void startThreadLocalTracking(std::span<uint8_t> region) override

virtual void stopThreadLocalTracking(std::span<uint8_t> region) override

virtual std::vector<char> getThreadLocalDirtyPages(std::span<uint8_t> region) override

virtual std::vector<char> getBothDirtyPages(std::span<uint8_t> region) override

Public Static Functions

static void handler(int sig, siginfo_t *info, void *ucontext) noexcept

class SnapshotData

Public Functions

SnapshotData() = default

explicit SnapshotData(size_t sizeIn)

SnapshotData(size_t sizeIn, size_t maxSizeIn)

explicit SnapshotData(std::span<const uint8_t> dataIn)

SnapshotData(std::span<const uint8_t> dataIn, size_t maxSizeIn)

SnapshotData(const SnapshotData&) = delete

SnapshotData &operator=(const SnapshotData&) = delete

~SnapshotData()

void copyInData(std::span<const uint8_t> buffer, uint32_t offset = 0)

const uint8_t *getDataPtr(uint32_t offset = 0)

std::vector<uint8_t> getDataCopy()

std::vector<uint8_t> getDataCopy(uint32_t offset, size_t dataSize)

void mapToMemory(std::span<uint8_t> target)

void addMergeRegion(uint32_t offset, size_t length, SnapshotDataType dataType, SnapshotMergeOperation operation)

void fillGapsWithBytewiseRegions()

void clearMergeRegions()

std::vector<SnapshotMergeRegion> getMergeRegions()

size_t getQueuedDiffsCount()

void applyDiffs(const std::vector<SnapshotDiff> &diffs)

void applyDiff(const SnapshotDiff &diff)

void queueDiffs(const std::vector<SnapshotDiff> &diffs)

int writeQueuedDiffs()

inline size_t getSize() const

inline size_t getMaxSize() const

std::vector<SnapshotDiff> getTrackedChanges()

void clearTrackedChanges()

std::vector<faabric::util::SnapshotDiff> diffWithDirtyRegions(std::span<uint8_t> updated, const std::vector<char> &dirtyRegions)

class SnapshotDiff

#include <snapshot.h>

Represents a modification to a snapshot (a.k.a. a dirty region). Specifies the modified data, as well as its offset within the snapshot.

Each diff does not own the data, it just provides a span pointing at the original data.

Public Functions

SnapshotDiff() = default

SnapshotDiff(SnapshotDataType dataTypeIn, SnapshotMergeOperation operationIn, uint32_t offsetIn, std::span<const uint8_t> dataIn)

inline SnapshotDataType getDataType() const

inline SnapshotMergeOperation getOperation() const

inline uint32_t getOffset() const

inline std::span<const uint8_t> getData() const

std::vector<uint8_t> getDataCopy() const

class SnapshotMergeRegion

#include <snapshot.h>

Defines how diffs in the given snapshot region should be interpreted wrt the original snapshot.

For example, it may specify that the change should be treated as an integer that needs to be summed (i.e. the diff is the current value minus the original), or just as a region of raw bytes that needs to be XORed with the original.

A merge region specifies an offset, length, data type and operation, e.g. an integer to be summed at offset 100 with a length of 4.

Public Functions

SnapshotMergeRegion() = default

SnapshotMergeRegion(uint32_t offsetIn, size_t lengthIn, SnapshotDataType dataTypeIn, SnapshotMergeOperation operationIn)

void addDiffs(std::vector<SnapshotDiff> &diffs, std::span<const uint8_t> originalData, std::span<uint8_t> updatedData, const std::vector<char> &dirtyRegions)

inline bool operator<(const SnapshotMergeRegion &other) const: This allows us to sort the merge regions which is important for diffing purposes.

inline bool operator==(const SnapshotMergeRegion &other) const

Public Members

uint32_t offset = 0

size_t length = 0

SnapshotDataType dataType = SnapshotDataType::Raw

SnapshotMergeOperation operation = SnapshotMergeOperation::Bytewise

class SoftPTEDirtyTracker : public faabric::util::DirtyTracker

Public Functions

SoftPTEDirtyTracker(const std::string &modeIn)

~SoftPTEDirtyTracker()

virtual void clearAll() override

inline virtual std::string getType() override

virtual void startTracking(std::span<uint8_t> region) override

virtual void stopTracking(std::span<uint8_t> region) override

virtual std::vector<char> getDirtyPages(std::span<uint8_t> region) override

virtual void startThreadLocalTracking(std::span<uint8_t> region) override

virtual void stopThreadLocalTracking(std::span<uint8_t> region) override

virtual std::vector<char> getThreadLocalDirtyPages(std::span<uint8_t> region) override

virtual std::vector<char> getBothDirtyPages(std::span<uint8_t> region) override

template<typename T> class SpinLockQueue

Public Functions

inline void enqueue(T &value)

inline T dequeue()

inline long size()

inline void drain()

inline void reset()

class SystemConfig

Public Functions

SystemConfig()

void print()

void reset()

Public Members

std::string serialisation

std::string logLevel

std::string logFile

std::string stateMode

std::string deltaSnapshotEncoding

std::string redisStateHost

std::string redisQueueHost

std::string redisPort

int overrideCpuCount

int overrideFreeCpuStart

std::string batchSchedulerMode

int globalMessageTimeout

int boundTimeout

int reaperIntervalSeconds

int defaultMpiWorldSize

std::string endpointInterface

std::string endpointHost

int endpointPort

int endpointNumThreads

int functionServerThreads

int stateServerThreads

int snapshotServerThreads

int pointToPointServerThreads

std::string dirtyTrackingMode

std::string diffingMode

std::string plannerHost

int plannerPort

class ThreadSafeDirtyTrackingRecord : public faabric::util::DirtyTrackingRecord

Thread-safe wrapper around dirty tracking data, necessary for use with the background event thread in the userfaultfd tracker. Although the logic around the interaction between the event thread and the main thread should in theory protect against concurrent accesses, we need this to keep TSan happy.

Public Functions

ThreadSafeDirtyTrackingRecord() = default

inline virtual void trackRegion(std::span<uint8_t> region) override

inline virtual void markPage(void *addr) override

inline virtual std::vector<char> getDirtyFlags() override

inline virtual bool isInitialised() override

inline virtual int getNPages() override

inline virtual void reset() override

class TokenPool

Public Functions

explicit TokenPool(int nTokens)

int getToken(): Blocking call to get an available token

void releaseToken(int token)

void reset()

int size()

int taken()

int free()

class UffdDirtyTracker : public faabric::util::DirtyTracker

#include <dirty.h>

Dirty tracking implementation using userfaultfd to write-protect pages, then handle the resulting userspace events when they are written to.

The dirty tracking mode can be one of four options:

uffd - uses the SIGBUS handler to catch events triggered by accessing missing pages in demand-zero paged memory.
uffd-wp - same as uffd but adds write-protected events to catch subsequent writes to write-protected pages.
uffd-thread - same as uffd, but using a background event thread to handle events. This has the benefit of distinguishing between read and write missing page events.
uffd-thread-wp - same as uffd-thread, but adds write-protected events.

See the docs for more info on these different approaches: https://www.kernel.org/doc/html/latest/admin-guide/mm/userfaultfd.html

Public Functions

UffdDirtyTracker(const std::string &modeIn)

~UffdDirtyTracker()

virtual void clearAll() override

inline virtual std::string getType() override

virtual void startTracking(std::span<uint8_t> region) override

virtual void stopTracking(std::span<uint8_t> region) override

virtual std::vector<char> getDirtyPages(std::span<uint8_t> region) override

virtual void startThreadLocalTracking(std::span<uint8_t> region) override

virtual void stopThreadLocalTracking(std::span<uint8_t> region) override

virtual std::vector<char> getThreadLocalDirtyPages(std::span<uint8_t> region) override

virtual std::vector<char> getBothDirtyPages(std::span<uint8_t> region) override

Public Static Functions

static void sigbusHandler(int sig, siginfo_t *info, void *ucontext) noexcept

namespace detail

template<typename> struct is_shared_ptr : public false_type

template<typename Pointee> struct is_shared_ptr<std::shared_ptr<Pointee>> : public true_type