Namespace faabric::planner

namespace planner

Typedefs

typedef std::promise<std::shared_ptr<faabric::Message>> MessageResultPromise

typedef std::shared_ptr<MessageResultPromise> MessageResultPromisePtr

using header = beast::http::field

Enums

enum FlushType

Values:

enumerator NoFlushType

enumerator Hosts

enumerator Executors

enumerator SchedulingState

enum PlannerCalls

Values:

enumerator NoPlanerCall

enumerator Ping

enumerator GetAvailableHosts

enumerator RegisterHost

enumerator RemoveHost

enumerator SetMessageResult

enumerator GetMessageResult

enumerator GetBatchResults

enumerator GetSchedulingDecision

enumerator GetNumMigrations

enumerator CallBatch

enumerator PreloadSchedulingDecision

Functions

Planner &getPlanner()

PlannerClient &getPlannerClient()

int availableOpenMpSlots(int appId, const std::string &mainHost, const std::map<std::string, std::shared_ptr<Host>> &hostMap, const faabric::batch_scheduler::InFlightReqs &inFlightReqs)

static void claimHostSlots(std::shared_ptr<Host> host, int slotsToClaim = 1)

static void releaseHostSlots(std::shared_ptr<Host> host, int slotsToRelease = 1)

static int claimHostMpiPort(std::shared_ptr<Host> host)

static void releaseHostMpiPort(std::shared_ptr<Host> host, int mpiPort)

static void printHostState(std::map<std::string, std::shared_ptr<Host>> hostMap, const std::string &logLevel = "debug")

static faabric::batch_scheduler::HostMap convertToBatchSchedHostMap(std::map<std::string, std::shared_ptr<Host>> hostMapIn, const std::set<std::string> &nextEvictedHostIps)

class KeepAliveThread : public faabric::util::PeriodicBackgroundThread

Public Functions

virtual void doWork() override

void setRequest(std::shared_ptr<RegisterHostRequest> thisHostReqIn)

Public Members

std::shared_ptr<RegisterHostRequest> thisHostReq = nullptr

class Planner

Public Functions

Planner()

PlannerConfig getConfig()

void printConfig() const

std::string getPolicy()

void setPolicy(const std::string &newPolicy)

bool reset()

bool flush(faabric::planner::FlushType flushType)

std::vector<std::shared_ptr<Host>> getAvailableHosts()

bool registerHost(const Host &hostIn, bool overwrite)

void removeHost(const Host &hostIn)

void setMessageResult(std::shared_ptr<faabric::Message> msg)

std::shared_ptr<faabric::Message> getMessageResult(std::shared_ptr<faabric::Message> msg)

void preloadSchedulingDecision(int appId, std::shared_ptr<batch_scheduler::SchedulingDecision> decision)

std::shared_ptr<batch_scheduler::SchedulingDecision> getPreloadedSchedulingDecision(int32_t appId, std::shared_ptr<BatchExecuteRequest> ber)

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

std::shared_ptr<faabric::batch_scheduler::SchedulingDecision> getSchedulingDecision(std::shared_ptr<BatchExecuteRequest> req)

faabric::batch_scheduler::InFlightReqs getInFlightReqs()

int getNumMigrations()

std::set<std::string> getNextEvictedHostIps()

std::map<int32_t, std::shared_ptr<BatchExecuteRequest>> getEvictedReqs()

std::shared_ptr<faabric::batch_scheduler::SchedulingDecision> callBatch(std::shared_ptr<BatchExecuteRequest> req)

void setNextEvictedVm(const std::set<std::string> &vmIp)

struct PlannerCache

Public Members

std::unordered_map<uint32_t, MessageResultPromisePtr> plannerResults

std::set<std::string> pushedSnapshots

class PlannerClient : public faabric::transport::MessageEndpointClient

Public Functions

PlannerClient()

PlannerClient(const std::string &plannerIp)

void ping()

void clearCache()

std::vector<Host> getAvailableHosts()

int registerHost(std::shared_ptr<RegisterHostRequest> req)

void removeHost(std::shared_ptr<RemoveHostRequest> req)

void setMessageResult(std::shared_ptr<faabric::Message> msg)

void setMessageResultLocally(std::shared_ptr<faabric::Message> msg)

faabric::Message getMessageResult(int appId, int msgId, int timeoutMs)

faabric::Message getMessageResult(const faabric::Message &msg, int timeoutMs)

std::shared_ptr<faabric::BatchExecuteRequestStatus> getBatchResults(std::shared_ptr<faabric::BatchExecuteRequest> req)

faabric::batch_scheduler::SchedulingDecision callFunctions(std::shared_ptr<faabric::BatchExecuteRequest> req)

faabric::batch_scheduler::SchedulingDecision getSchedulingDecision(std::shared_ptr<faabric::BatchExecuteRequest> req)

int getNumMigrations()

void preloadSchedulingDecision(std::shared_ptr<faabric::batch_scheduler::SchedulingDecision> preloadDec)

class PlannerEndpointHandler : public faabric::endpoint::HttpRequestHandler, public std::enable_shared_from_this<PlannerEndpointHandler>

Public Functions

virtual void onRequest(faabric::endpoint::HttpRequestContext &&ctx, faabric::util::BeastHttpRequest &&request) override

class PlannerServer : public faabric::transport::MessageEndpointServer

Public Functions

PlannerServer()

struct PlannerState

Public Members

std::string policy

std::map<std::string, std::shared_ptr<Host>> hostMap

std::map<int, std::map<int, std::shared_ptr<faabric::Message>>> appResults

std::map<int, std::vector<std::string>> appResultWaiters

faabric::batch_scheduler::InFlightReqs inFlightReqs

std::map<int, std::shared_ptr<batch_scheduler::SchedulingDecision>> preloadedSchedulingDecisions

std::atomic<int> numMigrations = 0

std::map<int, std::shared_ptr<BatchExecuteRequest>> evictedRequests

std::set<std::string> nextEvictedHostIps