Re-factor master to main

include/faabric/batch-scheduler/SchedulingDecision.h

@@ -5,13 +5,13 @@
 namespace faabric::batch_scheduler {
 // Scheduling topology hints help the scheduler decide which host to assign new
 // requests in a batch.
-//  - NONE: bin-packs requests to slots in hosts starting from the master
-//          host, and overloadds the master if it runs out of resources.
+//  - NONE: bin-packs requests to slots in hosts starting from the main
+//          host, and overloadds the main if it runs out of resources.
 //  - FORCE_LOCAL: force local execution irrespective of the available
 //                 resources.
-//  - NEVER_ALONE: never allocates a single (non-master) request to a host
+//  - NEVER_ALONE: never allocates a single (non-main) request to a host
 //                 without other requests of the batch.
-//  - UNDERFULL: schedule up to 50% of the master hosts' capacity to force
+//  - UNDERFULL: schedule up to 50% of the main hosts' capacity to force
 //               migration opportunities to appear.
 enum SchedulingTopologyHint
 {
@@ -82,7 +82,7 @@ class SchedulingDecision
     /**
      * Work out if this decision is all on this host. If the decision is
      * completely on *another* host, we still count it as not being on a single
-     * host, as this host will be the master.
+     * host, as this host will be the main.
      *
      * Will always return false if single host optimisations are switched off.
      */

include/faabric/state/InMemoryStateKeyValue.h

@@ -11,8 +11,8 @@
 namespace faabric::state {
 enum InMemoryStateKeyStatus
 {
-    NOT_MASTER,
-    MASTER,
+    NOT_MAIN,
+    MAIN,
 };
 
 class AppendedInMemoryState
@@ -55,7 +55,7 @@ class InMemoryStateKeyValue final : public StateKeyValue
 
   private:
     const std::string thisIP;
-    const std::string masterIP;
+    const std::string mainIP;
     InMemoryStateKeyStatus status;
 
     InMemoryStateRegistry& stateRegistry;

include/faabric/state/InMemoryStateRegistry.h

@@ -22,8 +22,8 @@ class InMemoryStateRegistry
     void clear();
 
   private:
-    std::unordered_map<std::string, std::string> masterMap;
-    std::shared_mutex masterMapMutex;
+    std::unordered_map<std::string, std::string> mainMap;
+    std::shared_mutex mainMapMutex;
 };
 
 InMemoryStateRegistry& getInMemoryStateRegistry();

include/faabric/transport/PointToPointBroker.h

@@ -17,7 +17,7 @@
 
 #define DEFAULT_DISTRIBUTED_TIMEOUT_MS 30000
 
-#define POINT_TO_POINT_MASTER_IDX 0
+#define POINT_TO_POINT_MAIN_IDX 0
 
 namespace faabric::transport {
 
@@ -63,7 +63,7 @@ class PointToPointGroup
   private:
     faabric::util::SystemConfig& conf;
 
-    std::string masterHost;
+    std::string mainHost;
     int appId = 0;
     int groupId = 0;
     int groupSize = 0;

include/faabric/util/snapshot.h

@@ -156,9 +156,9 @@ class SnapshotMergeRegion
 };
 
 /*
- * Calculates a diff value that can later be merged into the master copy of the
+ * Calculates a diff value that can later be merged into the main copy of the
  * given snapshot. It will be used on remote hosts to calculate the diffs that
- * are to be sent back to the master host.
+ * are to be sent back to the main host.
  */
 template<typename T>
 inline bool calculateDiffValue(const uint8_t* original,
@@ -210,7 +210,7 @@ inline bool calculateDiffValue(const uint8_t* original,
 }
 
 /*
- * Applies a diff value to the master copy of a snapshot, where the diff has
+ * Applies a diff value to the main copy of a snapshot, where the diff has
  * been calculated based on a change made to another copy of the same snapshot.
  */
 template<typename T>

src/mpi/MpiWorld.cpp

@@ -140,7 +140,7 @@ void MpiWorld::create(faabric::Message& call, int newId, int newSize)
 
     auto& sch = faabric::scheduler::getScheduler();
 
-    // Dispatch all the chained calls. With the master being rank zero, we want
+    // Dispatch all the chained calls. With the main being rank zero, we want
     // to spawn (size - 1) new functions starting with rank 1
     std::shared_ptr<faabric::BatchExecuteRequest> req =
       faabric::util::batchExecFactory(user, function, size - 1);
@@ -724,7 +724,7 @@ void MpiWorld::broadcast(int sendRank,
         }
     } else {
         // If we are neither the sending rank nor a local leader, we receive
-        // from either our leader master if the broadcast originated in a
+        // from either our local leader if the broadcast originated in a
         // different host, or the sending rank itself if we are on the same host
         int sendingRank =
           getHostForRank(sendRank) == thisHost ? sendRank : localLeader;

src/planner/Planner.cpp

@@ -245,9 +245,9 @@ std::shared_ptr<faabric::Message> Planner::getMessageResult(
 
     // If we are here, it means that we have not found the message result, so
     // we register the calling-host's interest if the calling-host has
-    // provided a masterhost. The masterhost is set when dispatching a message
+    // provided a main host. The main host is set when dispatching a message
     // within faabric, but not when sending an HTTP request
-    if (!msg->masterhost().empty()) {
+    if (!msg->mainhost().empty()) {
         faabric::util::FullLock lock(plannerMx);
 
         // Check again if the result is not set, as it could have been set
@@ -260,9 +260,9 @@ std::shared_ptr<faabric::Message> Planner::getMessageResult(
         // Definately the message result is not set, so we add the host to the
         // waiters list
         SPDLOG_DEBUG("Adding host {} on the waiting list for message {}",
-                     msg->masterhost(),
+                     msg->mainhost(),
                      msgId);
-        state.appResultWaiters[msgId].push_back(msg->masterhost());
+        state.appResultWaiters[msgId].push_back(msg->mainhost());
     }
 
     return nullptr;

src/planner/PlannerClient.cpp

@@ -167,10 +167,10 @@ std::shared_ptr<faabric::Message> PlannerClient::getMessageResultFromPlanner(
 faabric::Message PlannerClient::getMessageResult(const faabric::Message& msg,
                                                  int timeoutMs)
 {
-    // Deliberately make a copy here so that we can set the masterhost when
+    // Deliberately make a copy here so that we can set the main host when
     // registering interest in the results
     auto msgPtr = std::make_shared<faabric::Message>(msg);
-    msgPtr->set_masterhost(faabric::util::getSystemConfig().endpointHost);
+    msgPtr->set_mainhost(faabric::util::getSystemConfig().endpointHost);
     return doGetMessageResult(msgPtr, timeoutMs);
 }
 
@@ -181,7 +181,7 @@ faabric::Message PlannerClient::getMessageResult(int appId,
     auto msgPtr = std::make_shared<faabric::Message>();
     msgPtr->set_appid(appId);
     msgPtr->set_id(msgId);
-    msgPtr->set_masterhost(faabric::util::getSystemConfig().endpointHost);
+    msgPtr->set_mainhost(faabric::util::getSystemConfig().endpointHost);
     return doGetMessageResult(msgPtr, timeoutMs);
 }
 

src/proto/faabric.proto

@@ -92,7 +92,7 @@ message Message {
     // Each BER has a unique app id
     int32 appId = 2;
     int32 appIdx = 3;
-    string masterHost = 4;
+    string mainHost = 4;
 
     enum MessageType {
         CALL = 0;

src/scheduler/Executor.cpp

@@ -226,7 +226,7 @@ void Executor::executeTasks(std::vector<int> msgIdxs,
     faabric::Message& firstMsg = req->mutable_messages()->at(0);
     std::string thisHost = faabric::util::getSystemConfig().endpointHost;
 
-    bool isMaster = firstMsg.masterhost() == thisHost;
+    bool isMaster = firstMsg.mainhost() == thisHost;
     bool isThreads = req->type() == faabric::BatchExecuteRequest::THREADS;
     bool isSingleHost = req->singlehost();
     std::string snapshotKey = firstMsg.snapshotkey();
@@ -287,7 +287,7 @@ void Executor::executeTasks(std::vector<int> msgIdxs,
             // Here all threads are still executing, so we have to overload.
             // If any tasks are blocking we risk a deadlock, and can no
             // longer guarantee the application will finish. In general if
-            // we're on the master host and this is a thread, we should
+            // we're on the main host and this is a thread, we should
             // avoid the zeroth and first pool threads as they are likely to
             // be the main thread and the zeroth in the communication group,
             // so will be blocking.

src/scheduler/FunctionCallClient.cpp

@@ -152,7 +152,7 @@ faabric::HostResources FunctionCallClient::getResources()
     return response;
 }
 
-// This function call is used by the master host of an application to let know
+// This function call is used by the main host of an application to let know
 // other hosts running functions of the same application that a migration
 // opportunity has been found.
 void FunctionCallClient::sendPendingMigrations(

src/scheduler/FunctionCallServer.cpp

@@ -86,7 +86,7 @@ void FunctionCallServer::recvExecuteFunctions(std::span<const uint8_t> buffer)
         // This flags were set by the old endpoint, we temporarily set them here
         parsedMsg.mutable_messages()->at(0).set_timestamp(
           faabric::util::getGlobalClock().epochMillis());
-        parsedMsg.mutable_messages()->at(0).set_masterhost(
+        parsedMsg.mutable_messages()->at(0).set_mainhost(
           faabric::util::getSystemConfig().endpointHost);
     }
     scheduler.callFunctions(

src/scheduler/Scheduler.cpp

@@ -240,7 +240,7 @@
         faabric::Message& firstMsg = execs.back()->getBoundMessage();
         std::string user = firstMsg.user();
         std::string function = firstMsg.function();
-        std::string masterHost = firstMsg.masterhost();
+        std::string mainHost = firstMsg.mainhost();
 
         for (auto exec : execs) {
             long millisSinceLastExec = exec->getMillisSinceLastExec();
@@ -279,18 +279,18 @@
         }
 
         // Unregister this host if no more executors remain on this host, and
-        // it's not the master
+        // it's not the main
         if (execs.empty()) {
             SPDLOG_TRACE("No remaining executors for {}", key);
 
-            bool isMaster = thisHost == masterHost;
+            bool isMaster = thisHost == mainHost;
             if (!isMaster) {
                 faabric::UnregisterRequest req;
                 req.set_host(thisHost);
                 req.set_user(user);
                 req.set_function(function);
 
-                getFunctionCallClient(masterHost)->unregister(req);
+                getFunctionCallClient(mainHost)->unregister(req);
             }
 
             keysToRemove.emplace_back(key);
@@ -359,9 +359,9 @@
   std::shared_ptr<faabric::BatchExecuteRequest> req)
 {
     // We assume all the messages are for the same function and have the
-    // same master host
+    // same main host
     faabric::Message& firstMsg = req->mutable_messages()->at(0);
-    std::string masterHost = firstMsg.masterhost();
+    std::string mainHost = firstMsg.mainhost();
 
     // Get topology hint from message
     faabric::batch_scheduler::SchedulingTopologyHint topologyHint =
@@ -374,16 +374,16 @@
       topologyHint ==
       faabric::batch_scheduler::SchedulingTopologyHint::FORCE_LOCAL;
 
-    // If we're not the master host, we need to forward the request back to the
-    // master host. This will only happen if a nested batch execution happens.
-    if (!isForceLocal && masterHost != thisHost) {
+    // If we're not the main host, we need to forward the request back to the
+    // main host. This will only happen if a nested batch execution happens.
+    if (!isForceLocal && mainHost != thisHost) {
         std::string funcStr = faabric::util::funcToString(firstMsg, false);
-        SPDLOG_DEBUG("Forwarding {} back to master {}", funcStr, masterHost);
+        SPDLOG_DEBUG("Forwarding {} back to main {}", funcStr, mainHost);
 
-        getFunctionCallClient(masterHost)->executeFunctions(req);
+        getFunctionCallClient(mainHost)->executeFunctions(req);
         faabric::batch_scheduler::SchedulingDecision decision(
           firstMsg.appid(), firstMsg.groupid());
-        decision.returnHost = masterHost;
+        decision.returnHost = mainHost;
         return decision;
     }
 
@@ -477,7 +477,7 @@
             hosts.push_back(thisHost);
         }
     } else {
-        // At this point we know we're the master host, and we've not been
+        // At this point we know we're the main host, and we've not been
         // asked to force full local execution.
 
         // Work out how many we can handle locally
@@ -664,7 +664,7 @@
     faabric::Message& firstMsg = req->mutable_messages()->at(0);
     std::string funcStr = faabric::util::funcToString(firstMsg, false);
     int nMessages = req->messages_size();
-    bool isMaster = thisHost == firstMsg.masterhost();
+    bool isMaster = thisHost == firstMsg.mainhost();
     bool isMigration = req->type() == faabric::BatchExecuteRequest::MIGRATION;
 
     if (decision.hosts.size() != nMessages) {
@@ -676,14 +676,14 @@
         throw std::runtime_error("Invalid scheduler hint for messages");
     }
 
-    if (firstMsg.masterhost().empty()) {
-        SPDLOG_ERROR("Request {} has no master host", funcStr);
-        throw std::runtime_error("Message with no master host");
+    if (firstMsg.mainhost().empty()) {
+        SPDLOG_ERROR("Request {} has no main host", funcStr);
+        throw std::runtime_error("Message with no main host");
     }
 
     // Send out point-to-point mappings if necessary (unless being forced to
     // execute locally, in which case they will be transmitted from the
-    // master)
+    // main)
     bool isForceLocal =
       topologyHint ==
       faabric::batch_scheduler::SchedulingTopologyHint::FORCE_LOCAL;
@@ -1076,8 +1076,8 @@
     msg.set_finishtimestamp(faabric::util::getGlobalClock().epochMillis());
 
     // Remove the app from in-flight map if still there, and this host is the
-    // master host for the message
-    if (msg.masterhost() == thisHost) {
+    // main host for the message
+    if (msg.mainhost() == thisHost) {
         removePendingMigration(msg.appid());
     }
 
@@ -1100,11 +1100,11 @@
   const std::string& key,
   const std::vector<faabric::util::SnapshotDiff>& diffs)
 {
-    bool isMaster = msg.masterhost() == conf.endpointHost;
+    bool isMaster = msg.mainhost() == conf.endpointHost;
     if (isMaster) {
         if (!diffs.empty()) {
-            // On master we queue the diffs locally directly, on a remote
-            // host we push them back to master
+            // On main we queue the diffs locally directly, on a remote
+            // host we push them back to main
             SPDLOG_DEBUG("Queueing {} diffs for {} to snapshot {} (group {})",
                          diffs.size(),
                          faabric::util::funcToString(msg, false),
@@ -1123,7 +1123,7 @@
         setThreadResultLocally(msg.id(), returnValue);
     } else {
         // Push thread result and diffs together
-        getSnapshotClient(msg.masterhost())
+        getSnapshotClient(msg.mainhost())
           ->pushThreadResult(msg.id(), returnValue, key, diffs);
     }
 }