Cleaned the library to remove redundant function argument and interface
authorChao Mei <chaomei2@illinois.edu>
Thu, 30 Aug 2012 22:58:13 +0000 (17:58 -0500)
committerChao Mei <chaomei2@illinois.edu>
Thu, 30 Aug 2012 22:59:41 +0000 (17:59 -0500)
function

src/libs/ck-libs/ckloop/CkLoop.C
src/libs/ck-libs/ckloop/CkLoopAPI.h

index 401101d07e3cf0749b50490decd1a0ac897b46c8..31369c584e5ea2fe79ca2d4323b1ed759d316955 100644 (file)
@@ -5,6 +5,9 @@
 #include "qd.h"
 #endif
 
+#define CKLOOP_USECHARM 1
+#define CKLOOP_PTHREAD 2
+
 /*====Beginning of pthread-related variables and impelementation====*/
 //__thread is not portable, but it works almost everywhere if pthread works
 //After C++11, this should be thread_local
@@ -454,17 +457,20 @@ void CurLoopInfo::stealWork() {
 //   End of functions related with FuncSingleHelper                     //
 //======================================================================//
 
-CProxy_FuncCkLoop CkLoop_Init(int mode, int numThreads) {
-    if (mode == CKLOOP_USECHARM) {
+CProxy_FuncCkLoop CkLoop_Init(int numThreads) {
+    int mode;
+#if CMK_SMP
+    mode = CKLOOP_USECHARM;
 #if USE_CONVERSE_NOTIFICATION
-        CkPrintf("CkLoopLib is used in SMP with a simple dynamic scheduling (converse-level notification) but not using node-level queue\n");
+    CkPrintf("CkLoopLib is used in SMP with a simple dynamic scheduling (converse-level notification) but not using node-level queue\n");
 #else
-        CkPrintf("CkLoopLib is used in SMP with a simple dynamic scheduling (charm-level notifiation) but not using node-level queue\n");
+    CkPrintf("CkLoopLib is used in SMP with a simple dynamic scheduling (charm-level notifiation) but not using node-level queue\n");
+#endif
+#else
+    mode = CKLOOP_PTHREAD;
+    CkPrintf("CkLoopLib is used with extra %d pthreads via a simple dynamic scheduling\n", numThreads);
+    CmiAssert(numThreads>0);
 #endif
-    } else if (mode==CKLOOP_PTHREAD) {
-        CkPrintf("CkLoopLib is used with extra %d pthreads via a simple dynamic scheduling\n", numThreads);
-        CmiAssert(numThreads>0);
-    }
     return CProxy_FuncCkLoop::ckNew(mode, numThreads);
 }
 
@@ -472,14 +478,6 @@ void CkLoop_Exit(CProxy_FuncCkLoop ckLoop) {
     ckLoop.exit();
 }
 
-void CkLoop_Parallelize(CProxy_FuncCkLoop ckLoop, HelperFn func,
-                            int paramNum, void * param,
-                            int numChunks, int lowerRange, int upperRange,
-                            int sync,
-                            void *redResult, REDUCTION_TYPE type) {
-    ckLoop[CkMyNode()].ckLocalBranch()->parallelizeFunc(func, paramNum, param, numChunks, lowerRange, upperRange, sync, redResult, type);
-}
-
 void CkLoop_Parallelize(HelperFn func,
                             int paramNum, void * param,
                             int numChunks, int lowerRange, int upperRange,
index 453821872f2314f69475301135668bacf9fd4fe7..4fef9a9e609919db8104a9f516252eb17ce11bf3 100644 (file)
@@ -13,28 +13,17 @@ typedef enum REDUCTION_TYPE {
     CKLOOP_DOUBLE_SUM
 } REDUCTION_TYPE;
 
-#define CKLOOP_USECHARM 1
-#define CKLOOP_PTHREAD 2
-
 class CProxy_FuncCkLoop;
 /*
- * The default mode is intended to be used in SMP mode
- * The next mode that uses pthread is intended to be used in a restricted mode where
- * a node just have one charm PE!
+ * "numThreads" argument is intended to be used in non-SMP mode to specify
+ * the number of pthreads to be spawned. In SMP mode, this argument is
+ * ignored. This function should be called only on one PE, say PE 0.
  **/
-extern CProxy_FuncCkLoop CkLoop_Init(int mode=CKLOOP_USECHARM, int numThreads=0);
+extern CProxy_FuncCkLoop CkLoop_Init(int numThreads=0);
 
-extern void CkLoop_Exit(CProxy_FuncCkLoop ckLoop); /* used to free resources if using pthread mode. It should be called on just one PE, say PE 0 */
+/* used to free resources if using the library in non-SMP mode. It should be called on just one PE, say PE 0 */
+extern void CkLoop_Exit(CProxy_FuncCkLoop ckLoop); 
 
-extern void CkLoop_Parallelize(
-    CProxy_FuncCkLoop ckLoop, /* the proxy to the FuncCkLoop instance */
-    HelperFn func, /* the function that finishes a partial work on another thread */
-    int paramNum, void * param, /* the input parameters for the above func */
-    int numChunks, /* number of chunks to be partitioned */
-    int lowerRange, int upperRange, /* the loop-like parallelization happens in [lowerRange, upperRange] */
-    int sync=1, /* whether the flow will continue unless all chunks have finished */
-    void *redResult=NULL, REDUCTION_TYPE type=CKLOOP_NONE /* the reduction result, ONLY SUPPORT SINGLE VAR of TYPE int/float/double */
-);
 extern void CkLoop_Parallelize(
     HelperFn func, /* the function that finishes a partial work on another thread */
     int paramNum, void * param, /* the input parameters for the above func */