Rename CoreManager-->CorePolicy

Author: Henry Qin

Makefile

@@ -31,7 +31,7 @@ CHECK_TARGET=$$(find $(SRC_DIR) $(WRAPPER_DIR) '(' -name '*.h' -or -name '*.cc'
 endif
 
 # Conversion to fully qualified names
-OBJECT_NAMES := Arachne.o Logger.o PerfStats.o DefaultCoreManager.o CoreLoadEstimator.o arachne_wrapper.o
+OBJECT_NAMES := Arachne.o Logger.o PerfStats.o DefaultCorePolicy.o CoreLoadEstimator.o arachne_wrapper.o
 
 OBJECTS = $(patsubst %,$(OBJECT_DIR)/%,$(OBJECT_NAMES))
 HEADERS= $(shell find $(SRC_DIR) $(WRAPPER_DIR) -name '*.h')
@@ -81,11 +81,11 @@ CTEST_LIBS=-Lobj/ -lArachne
 INCLUDE+=-I${GTEST_DIR}/include -I${GMOCK_DIR}/include
 COREARBITER_BIN=$(COREARBITER)/bin/coreArbiterServer
 
-test: $(OBJECT_DIR)/ArachneTest $(OBJECT_DIR)/CoreManagerTest $(OBJECT_DIR)/DefaultCoreManagerTest $(OBJECT_DIR)/arachne_wrapper_test
+test: $(OBJECT_DIR)/ArachneTest $(OBJECT_DIR)/CorePolicyTest $(OBJECT_DIR)/DefaultCorePolicyTest $(OBJECT_DIR)/arachne_wrapper_test
 	$(OBJECT_DIR)/ArachneTest
-	$(OBJECT_DIR)/DefaultCoreManagerTest
+	$(OBJECT_DIR)/DefaultCorePolicyTest
 	$(OBJECT_DIR)/arachne_wrapper_test
-	$(OBJECT_DIR)/CoreManagerTest
+	$(OBJECT_DIR)/CorePolicyTest
 
 ctest: $(OBJECT_DIR)/arachne_wrapper_ctest
 	$(OBJECT_DIR)/arachne_wrapper_ctest
@@ -99,10 +99,10 @@ $(OBJECT_DIR)/arachne_wrapper_test: $(OBJECT_DIR)/arachne_wrapper_test.o $(OBJEC
 $(OBJECT_DIR)/ArachneTest: $(OBJECT_DIR)/ArachneTest.o $(OBJECT_DIR)/libgtest.a $(OBJECT_DIR)/libArachne.a
 	$(CXX) $(INCLUDE) $(CXXFLAGS) $< $(GTEST_DIR)/src/gtest_main.cc $(TEST_LIBS) $(LIBS)  -o $@
 
-$(OBJECT_DIR)/DefaultCoreManagerTest: $(OBJECT_DIR)/DefaultCoreManagerTest.o $(OBJECT_DIR)/libgtest.a $(OBJECT_DIR)/libArachne.a
+$(OBJECT_DIR)/DefaultCorePolicyTest: $(OBJECT_DIR)/DefaultCorePolicyTest.o $(OBJECT_DIR)/libgtest.a $(OBJECT_DIR)/libArachne.a
 	$(CXX) $(INCLUDE) $(CXXFLAGS) $< $(GTEST_DIR)/src/gtest_main.cc $(TEST_LIBS) $(LIBS)  -o $@
 
-$(OBJECT_DIR)/CoreManagerTest: $(OBJECT_DIR)/CoreManagerTest.o $(OBJECT_DIR)/libgtest.a $(OBJECT_DIR)/libArachne.a
+$(OBJECT_DIR)/CorePolicyTest: $(OBJECT_DIR)/CorePolicyTest.o $(OBJECT_DIR)/libgtest.a $(OBJECT_DIR)/libArachne.a
 	$(CXX) $(INCLUDE) $(CXXFLAGS) $< $(GTEST_DIR)/src/gtest_main.cc $(TEST_LIBS) $(LIBS)  -o $@
 
 $(OBJECT_DIR)/libgtest.a:

cwrapper/arachne_wrapper.cc

@@ -18,7 +18,7 @@
 
 #include "Arachne.h"
 #include "CoreArbiter/CoreArbiterClient.h"
-#include "DefaultCoreManager.h"
+#include "DefaultCorePolicy.h"
 #include "arachne_wrapper.h"
 
 #ifdef __cplusplus
@@ -70,7 +70,7 @@ arachne_wait_termination() {
 
 /**
  * This function is the wrapper for Arachne::createThreadWithClass.
- * Under Arachne's default core manager, the following thread classes are
+ * Under Arachne's default core policy, the following thread classes are
  * available.
  *
  *    Class 0: Normal thread creation
@@ -146,7 +146,7 @@ arachne_thread_getid() {
  */
 void
 arachne_set_maxutil(double maxutil) {
-    reinterpret_cast<Arachne::DefaultCoreManager*>(Arachne::getCoreManager())
+    reinterpret_cast<Arachne::DefaultCorePolicy*>(Arachne::getCorePolicy())
         ->getEstimator()
         ->setMaxUtilization(maxutil);
 }
@@ -157,8 +157,8 @@ arachne_set_maxutil(double maxutil) {
  */
 void
 arachne_set_loadfactor(double loadfactor) {
-    reinterpret_cast<Arachne::DefaultCoreManager*>(
-        Arachne::getCoreManager())
+    reinterpret_cast<Arachne::DefaultCorePolicy*>(
+        Arachne::getCorePolicy())
         ->getEstimator()
         ->setLoadFactorThreshold(loadfactor);
 }

src/Arachne.cc

@@ -16,8 +16,8 @@
 #include <stdio.h>
 #include <thread>
 #include "CoreArbiter/CoreArbiterClient.h"
-#include "CoreManager.h"
-#include "DefaultCoreManager.h"
+#include "CorePolicy.h"
+#include "DefaultCorePolicy.h"
 #include "PerfUtils/TimeTrace.h"
 #include "PerfUtils/Util.h"
 
@@ -207,9 +207,9 @@ std::string coreArbiterSocketPath;
 CoreArbiterClient* coreArbiter = NULL;
 
 /*
- *  The CoreManager that Arachne will use.
+ *  The CorePolicy that Arachne will use.
  */
-CoreManager* coreManager = NULL;
+CorePolicy* corePolicy = NULL;
 
 // Forward declarations
 void releaseCore();
@@ -284,7 +284,7 @@ threadMain() {
             *core.localOccupiedAndCount = {0, 0};
             *publicPriorityMasks[core.kernelThreadId] = 0;
             core.privatePriorityMask = 0;
-            coreManager->coreAvailable(core.kernelThreadId);
+            corePolicy->coreAvailable(core.kernelThreadId);
 
             // This marks the point at which new thread creations may begin.
             numActiveCores++;
@@ -805,8 +805,8 @@ waitForTermination() {
     publicPriorityMasks.clear();
     PerfUtils::Util::serialize();
     coreArbiter->reset();
-    delete coreManager;
-    coreManager = NULL;
+    delete corePolicy;
+    corePolicy = NULL;
     initialized = false;
 }
 
@@ -957,30 +957,30 @@ ThreadContext::initializeStack() {
  * than the default. This function should be invoked before Arachne::init(),
  * and the object passed in is owned by Arachne after this function returns.
  *
- * \param arachneCoreManager
- *    A pointer to the CoreManager that Arachne will use.  The CoreManager
+ * \param arachneCorePolicy
+ *    A pointer to the CorePolicy that Arachne will use.  The CorePolicy
  *    controls thread allocation to cores.
  */
 void
-setCoreManager(CoreManager* arachneCoreManager) {
+setCorePolicy(CorePolicy* arachneCorePolicy) {
     if (initialized) {
         ARACHNE_LOG(ERROR,
                     "Attempting to set core policy after Arachne::init has "
                     "already been invoked");
         abort();
     }
-    if (coreManager != NULL)
-        delete coreManager;
-    coreManager = arachneCoreManager;
+    if (corePolicy != NULL)
+        delete corePolicy;
+    corePolicy = arachneCorePolicy;
 }
 
 /**
  * Get the current core policy used by Arachne. This should be used only for
  * testing.
  */
-CoreManager*
-getCoreManager() {
-    return coreManager;
+CorePolicy*
+getCorePolicy() {
+    return corePolicy;
 }
 
 /**
@@ -1044,9 +1044,9 @@ init(int* argcp, const char** argv) {
                     maxNumCores, hardwareCoresAvailable);
     }
 
-    if (coreManager == NULL) {
-        coreManager =
-            new DefaultCoreManager(maxNumCores, !disableLoadEstimation);
+    if (corePolicy == NULL) {
+        corePolicy =
+            new DefaultCorePolicy(maxNumCores, !disableLoadEstimation);
     }
 
     std::vector<uint32_t> coreRequest({minNumCores, 0, 0, 0, 0, 0, 0, 0});
@@ -1420,18 +1420,18 @@ descheduleCore() {
         }
         coreId = ownedCores.back();
         ownedCores.pop_back();
-        coreManager->coreUnavailable(coreId);
+        corePolicy->coreUnavailable(coreId);
     }
     if (createThreadOnCore(coreId, releaseCore) == NullThread) {
-        coreManager->coreAvailable(coreId);
+        corePolicy->coreAvailable(coreId);
         coreChangeActive = false;
         ARACHNE_LOG(WARNING, "Release core thread creation failed to %d!\n",
                     coreId);
     }
 }
 
 /**
- * This function can be called from CoreManagers to increase the number of
+ * This function can be called from CorePolicys to increase the number of
  * cores used by Arachne.
  */
 void
@@ -1503,7 +1503,7 @@ checkForArbiterRequest() {
 /**
  * After this function returns, threads may no longer be added to the target
  * core. This function can be invoked from any thread on any core. It is
- * invoked by CoreManagers to block creations when cores transition
+ * invoked by CorePolicys to block creations when cores transition
  * between thread classes.
  */
 void
@@ -1576,8 +1576,8 @@ migrateThreadsFromCore() {
         // Choose a victim core that we will pawn our work on.
         if ((blockedOccupiedAndCount.occupied >> i) & 1) {
             int threadClass = core.localThreadContexts[i]->threadClass;
-            CoreManager::CoreList outputCores =
-                coreManager->getCores(threadClass);
+            CorePolicy::CoreList outputCores =
+                corePolicy->getCores(threadClass);
             if (outputCores.size() == 0) {
                 ARACHNE_LOG(ERROR, "No available cores to migrate threads to.");
                 exit(1);
@@ -1749,7 +1749,7 @@ prepareForExclusiveUse(int coreId) {
  * CoreList and return its Id.
  */
 int
-findAndClaimUnusedCore(CoreManager::CoreList* cores) {
+findAndClaimUnusedCore(CorePolicy::CoreList* cores) {
     for (uint32_t i = 0; i < cores->size(); i++) {
         int coreId = cores->get(i);
         MaskAndCount slotMap = *occupiedAndCount[coreId];

src/Arachne.h

@@ -28,7 +28,7 @@
 #include <vector>
 
 #include "Common.h"
-#include "CoreManager.h"
+#include "CorePolicy.h"
 #include "Logger.h"
 #include "PerfStats.h"
 #include "PerfUtils/Cycles.h"
@@ -72,7 +72,7 @@ extern std::function<void()> initCore;
 
 extern std::vector<ThreadContext**> allThreadContexts;
 
-extern CoreManager* coreManager;
+extern CorePolicy* corePolicy;
 
 extern std::atomic<bool>* coreIdle;
 
@@ -137,11 +137,11 @@ void idleCore(int coreId);
 void unidleCore(int coreId);
 
 bool removeAllThreadsFromCore(int coreId,
-                              CoreManager::CoreManager::CoreList outputCores);
+                              CorePolicy::CorePolicy::CoreList outputCores);
 void makeSharedOnCore();
 
-void setCoreManager(CoreManager* arachneCoreManager);
-CoreManager* getCoreManager();
+void setCorePolicy(CorePolicy* arachneCorePolicy);
+CorePolicy* getCorePolicy();
 
 void block();
 void signal(ThreadId id);
@@ -312,7 +312,7 @@ struct ThreadContext {
 
     /// Specified by applications to indicate general properties of this thread
     /// (e.g. latency-sensitive foreground thread vs throughput-sensitive
-    /// background thread); used by CoreManager.
+    /// background thread); used by CorePolicy.
     // It defaults to 0 for threads created without specifying a class.
     int threadClass = 0;
 
@@ -451,7 +451,7 @@ random(void) {
 // in the CC file causes the compiler to generate an independent version of the
 // random() function above.
 static int
-chooseCore(const CoreManager::CoreList& coreList) {
+chooseCore(const CorePolicy::CoreList& coreList) {
     uint32_t index1 = static_cast<uint32_t>(random()) % coreList.size();
     uint32_t index2 = static_cast<uint32_t>(random()) % coreList.size();
     while (index2 == index1 && coreList.size() > 1)
@@ -554,7 +554,7 @@ createThreadOnCore(uint32_t coreId, _Callable&& __f, _Args&&... __args) {
     return ThreadId(threadContext, generation);
 }
 
-int chooseCore(const CoreManager::CoreList& coreList);
+int chooseCore(const CorePolicy::CoreList& coreList);
 
 ////////////////////////////////////////////////////////////////////////////////
 // The ends the private section of the thread library.
@@ -565,7 +565,7 @@ int chooseCore(const CoreManager::CoreList& coreList);
  *
  * \param threadClass
  *     The class of the thread being created; its meaning is determined by the
- *     currently running CoreManager.
+ *     currently running CorePolicy.
  * \param __f
  *     The main function for the new thread.
  * \param __args
@@ -584,7 +584,7 @@ ThreadId
 createThreadWithClass(int threadClass, _Callable&& __f, _Args&&... __args) {
     // Find a core to enqueue to by picking two at random and choosing
     // the one with the fewest Arachne threads.
-    CoreManager::CoreList coreList = coreManager->getCores(threadClass);
+    CorePolicy::CoreList coreList = corePolicy->getCores(threadClass);
     if (coreList.size() == 0)
         return Arachne::NullThread;
     uint32_t kId = static_cast<uint32_t>(chooseCore(coreList));