Changes between Version 8 and Version 9 of AppMultiThread

Timestamp:

Nov 24, 2007, 3:26:21 PM (16 years ago)

Author:

davea

Comment:

--

AppMultiThread

@@ -23 +23 @@
 == Assumptions ==
 
+We assume that applications have the following properties:
+
+ * Given a number of CPUs N, the app can select a number of threads so that it uses N CPUs as fully as possible.  This number may be less than or greater than N; it may be 1.
+ * There may be periods during the app's execution during which its number of threads becomes less than N; e.g. there may be periods during which the app is not parallel, and the number of threads becomes 1.
+
+== Scheduling policy ==
+
 Suppose an app A uses NT(A) threads.
+Ideally, on a host with N CPUs, we want
+NT(A), summed over running apps, to be at least N;
+otherwise CPU time is wasted.
+However, if it's much more than N,
+we increase latency without increasing throughput,
+we may increase synchronization overhead,
+and we may use more RAM than needed.
 
-Ideally, on a host with N CPUs, we want
-NT(A), summed over running apps, to be about N.
-If it's less, we're not using CPU time.
-If it's more, then
- * we increase latency without increasing throughput
- * we use more RAM than needed
- * synchronization overhead is high
+Our scheduling policy, given N CPUs, is:
 
-We assume that applications may be able to change NT(A) dynamically
-in response to suggestions from BOINC.
+ * Instruct applications to use enough threads for N CPUs, and monitor how many threads NT(A) they actually use.
+ * Given a set of runnable applications A1, A2 (ordered by priority or deadline), run applications until the number of actual threads exceeds N.
+ * Reschedule the CPUs whenever NT(A) changes for a running app A.
 
-Example: suppose
- * we have an 80-core CPU
- * app A can use 1,2,4,8,16,32 threads
- * app B can use 1,2,4,8,16,32,64 threads
 
-Then we want to have either (16, 64) or (32, 32, 16) threads most of the time.
-
-== Proposal ==
+== API ==
 
 API functions:
 {{{
-int boinc_nthreads_hint();
+int boinc_ncpus();
 }}}
-An application calls {{{boinc_nthreads_hint()}}} periodically,
-at points where it is able to change its number of threads.
-It returns a suggested number N of threads.
-The application should change its number of threads to
-a value as large as possible but no greater than N.
+This returns the number of available CPUs
+(this may be less than the number of physical CPUs,
+if the user preferences specify this).
+An application should call {{{boinc_ncpus()}}} on startup
+to decide how many threads to use.
+It may optionally call it again at points where it is able to change its number of threads,
+in case the number of available CPUs has changed
+(e.g. as the computer becomes idle and busy).
 {{{
-void boinc_nthreads(int actual, int possible);
+void boinc_nthreads(int actual);
 }}}
-An application calls this to report its actual number of threads,
-and its maximum possible number of threads.
-It should call this whenever either quantity changes.
+An application calls this to report its actual number of threads.
+It should call this whenever this quantity changes.
 
 A WU DB record can specify "max average threads",
-an estimate of the average  value of NT(A) on a host with arbitrarily many CPUs.
+an estimate of the average number of threads on a host with arbitrarily many CPUs.
 This is used by the client and scheduler to estimate completion time.
 
 == Implementation ==
 
+App init file:
+ * <ncpus_available>
+
 Shared-memory messages:
- * core->app (process control channel): {{{<target_nthreads>}}}
- * app->core (process control channel): {{{<actual_nthreads>}}}
+ * core->app (process control channel): {{{<ncpus_available>}}}
+ * app->core (process control channel): {{{<nthreads>}}}
 
-Client maintains estimates of CPU efficiency per job,
-uses this to scale {{{target_nthreads}}}.
+State:
+ * ACTIVE_TASK::nthreads_actual
 
 Implementation ({{{enforce_schedule()}}}):
-as we schedule jobs, decrement CPU count by scaled {{{actual_nthreads}}}.
+as we schedule jobs, decrement CPU count by {{{actual_nthreads}}}.
 {{{rr_simulation()}}} needs to be modified too.