Merge branch 'maint'

* maint:
  add erl option to set schedulers by percentages

4 files changed, 238 insertions, 63 deletions

diff --git a/erts/doc/src/erl.xml b/erts/doc/src/erl.xml
index c151b35d77..dfd16c3d19 100644
--- a/erts/doc/src/erl.xml
+++ b/erts/doc/src/erl.xml
@@ -748,19 +748,47 @@
       </item>
       <tag><marker id="+S"><c><![CDATA[+S Schedulers:SchedulerOnline]]></c></marker></tag>
       <item>
-        <p>Sets the amount of scheduler threads to create and scheduler
-	  threads to set online when SMP support has been enabled.
-	  Valid range for both values are 1-1024. If the
-          Erlang runtime system is able to determine the amount
-          of logical processors configured and logical processors available,
-	  <c>Schedulers</c> will default to logical processors configured,
-	  and <c>SchedulersOnline</c> will default to logical processors
-	  available; otherwise, the default values will be 1. <c>Schedulers</c>
-	  may be omitted if <c>:SchedulerOnline</c> is not and vice versa. The
-	  amount of schedulers online can be changed at run time via
+        <p>Sets the number of scheduler threads to create and scheduler
+	  threads to set online when SMP support has been enabled. The maximum for
+	  both values is 1024. If the Erlang runtime system is able to determine the
+	  amount of logical processors configured and logical processors available,
+	  <c>Schedulers</c> will default to logical processors configured, and
+	  <c>SchedulersOnline</c> will default to logical processors available;
+	  otherwise, the default values will be 1. <c>Schedulers</c> may be omitted
+	  if <c>:SchedulerOnline</c> is not and vice versa. The number of schedulers
+	  online can be changed at run time via
 	  <seealso marker="erlang#system_flag_schedulers_online">erlang:system_flag(schedulers_online, SchedulersOnline)</seealso>.
 	</p>
-        <p>This flag will be ignored if the emulator doesn't have
+	<p>If <c>Schedulers</c> or <c>SchedulersOnline</c> is specified as a
+	  negative number, the value is subtracted from the default number of
+	  logical processors configured or logical processors available, respectively.
+	</p>
+	<p>Specifying the value 0 for <c>Schedulers</c> or <c>SchedulersOnline</c>
+	  resets the number of scheduler threads or scheduler threads online respectively
+	  to its default value.
+	</p>
+        <p>This option is ignored if the emulator doesn't have
+          SMP support enabled (see the <seealso marker="#smp">-smp</seealso>
+          flag).</p>
+      </item>
+      <tag><marker id="+SP"><c><![CDATA[+SP SchedulersPercentage:SchedulersOnlinePercentage]]></c></marker></tag>
+      <item>
+        <p>Similar to <seealso marker="#+S">+S</seealso> but uses percentages to set the
+	  number of scheduler threads to create, based on logical processors configured,
+	  and scheduler threads to set online, based on logical processors available, when
+	  SMP support has been enabled. Specified values must be greater than 0. For example,
+	  <c>+SP 50:25</c> sets the number of scheduler threads to 50% of the logical processors
+	  configured and the number of scheduler threads online to 25% of the logical processors available.
+	  <c>SchedulersPercentage</c> may be omitted if <c>:SchedulersOnlinePercentage</c> is
+	  not and vice versa. The number of schedulers online can be changed at run time via
+	  <seealso marker="erlang#system_flag_schedulers_online">erlang:system_flag(schedulers_online, SchedulersOnline)</seealso>.
+	</p>
+	<p>This option interacts with <seealso marker="#+S">+S</seealso> settings.
+	  For example, on a system with 8 logical cores configured and 8 logical cores
+	  available, the combination of the options <c>+S 4:4 +SP 50:25</c> (in either order)
+	  results in 2 scheduler threads (50% of 4) and 1 scheduler thread online (25% of 4).
+	</p>
+        <p>This option is ignored if the emulator doesn't have
           SMP support enabled (see the <seealso marker="#smp">-smp</seealso>
           flag).</p>
       </item>
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 8d137df7ae..f7bfa91b54 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -549,9 +549,12 @@ void erts_usage(void)
 		 ERTS_SCHED_THREAD_MAX_STACK_SIZE);
     erts_fprintf(stderr, "-spp Bool   set port parallelism scheduling hint\n");
     erts_fprintf(stderr, "-S n1:n2    set number of schedulers (n1), and number of\n");
-    erts_fprintf(stderr, "            schedulers online (n2), valid range for both\n");
-    erts_fprintf(stderr, "            numbers are [1-%d]\n",
+    erts_fprintf(stderr, "            schedulers online (n2), maximum for both\n");
+    erts_fprintf(stderr, "            numbers is %d\n",
 		 ERTS_MAX_NO_OF_SCHEDULERS);
+    erts_fprintf(stderr, "-SP p1:p2   specify schedulers (p1) and schedulers online (p2)\n");
+    erts_fprintf(stderr, "	      as percentages of logical processors configured and logical\n");
+    erts_fprintf(stderr, "	      processors available, respectively\n");
     erts_fprintf(stderr, "-t size     set the maximum number of atoms the "
 			 "emulator can handle\n");
     erts_fprintf(stderr, "            valid range is [%d-%d]\n",
@@ -631,6 +634,8 @@ early_init(int *argc, char **argv) /*
     int ncpuavail;
     int schdlrs;
     int schdlrs_onln;
+    int schdlrs_percentage = 100;
+    int schdlrs_onln_percentage = 100;
     int max_main_threads;
     int max_reader_groups;
     int reader_groups;
@@ -758,63 +763,128 @@ early_init(int *argc, char **argv) /*
 		    }
 		    break;
 		}
-		case 'S' : {
-		    int tot, onln;
-		    char *arg = get_arg(argv[i]+2, argv[i+1], &i);
-		    switch (sscanf(arg, "%d:%d", &tot, &onln)) {
-		    case 0:
-			switch (sscanf(arg, ":%d", &onln)) {
+		case 'S' :
+		    if (argv[i][2] == 'P') {
+			int ptot, ponln;
+			char *arg = get_arg(argv[i]+3, argv[i+1], &i);
+			switch (sscanf(arg, "%d:%d", &ptot, &ponln)) {
+			case 0:
+			    switch (sscanf(arg, ":%d", &ponln)) {
+			    case 1:
+				if (ponln < 0)
+				    goto bad_SP;
+				ptot = 100;
+				goto chk_SP;
+			    default:
+				goto bad_SP;
+			    }
 			case 1:
-			    tot = no_schedulers;
-			    goto chk_S;
+			    if (ptot < 0)
+				goto bad_SP;
+			    ponln = ptot < 100 ? ptot : 100;
+			    goto chk_SP;
+			case 2:
+			    if (ptot < 0 || ponln < 0)
+				goto bad_SP;
+			chk_SP:
+			    schdlrs_percentage = ptot;
+			    schdlrs_onln_percentage = ponln;
+			    break;
 			default:
-			    goto bad_S;
-			}
-		    case 1:
-			onln = tot < schdlrs_onln ? tot : schdlrs_onln;
-		    case 2:
-		    chk_S:
-			if (tot > 0)
-			    schdlrs = tot;
-			else
-			    schdlrs = no_schedulers + tot;
-			if (onln > 0)
-			    schdlrs_onln = onln;
-			else
-			    schdlrs_onln = no_schedulers_online + onln;
-			if (schdlrs < 1 || ERTS_MAX_NO_OF_SCHEDULERS < schdlrs) {
-			    erts_fprintf(stderr,
-					 "bad amount of schedulers %d\n",
-					 tot);
-			    erts_usage();
-			}
-			if (schdlrs_onln < 1 || schdlrs < schdlrs_onln) {
+                        bad_SP:
+                            erts_fprintf(stderr,
+                                         "bad schedulers percentage specifier %s\n",
+                                         arg);
+                            erts_usage();
+                            break;
+                        }
+
+                        VERBOSE(DEBUG_SYSTEM,
+                                ("using %d:%d scheduler percentages\n",
+                                 schdlrs_percentage, schdlrs_onln_percentage));
+                    } else {
+			int tot, onln;
+			char *arg = get_arg(argv[i]+2, argv[i+1], &i);
+			switch (sscanf(arg, "%d:%d", &tot, &onln)) {
+			case 0:
+			    switch (sscanf(arg, ":%d", &onln)) {
+			    case 1:
+				tot = no_schedulers;
+				goto chk_S;
+			    default:
+				goto bad_S;
+			    }
+			case 1:
+			    onln = tot < schdlrs_onln ? tot : schdlrs_onln;
+			case 2:
+			chk_S:
+			    if (tot > 0)
+				schdlrs = tot;
+			    else
+				schdlrs = no_schedulers + tot;
+			    if (onln > 0)
+				schdlrs_onln = onln;
+			    else
+				schdlrs_onln = no_schedulers_online + onln;
+			    if (schdlrs < 1 || ERTS_MAX_NO_OF_SCHEDULERS < schdlrs) {
+				erts_fprintf(stderr,
+					     "bad amount of schedulers %d\n",
+					     tot);
+				erts_usage();
+			    }
+			    if (schdlrs_onln < 1 || schdlrs < schdlrs_onln) {
+				erts_fprintf(stderr,
+					     "bad amount of schedulers online %d "
+					     "(total amount of schedulers %d)\n",
+					     schdlrs_onln, schdlrs);
+				erts_usage();
+			    }
+			    break;
+			default:
+			bad_S:
 			    erts_fprintf(stderr,
-					 "bad amount of schedulers online %d "
-					 "(total amount of schedulers %d)\n",
-					 schdlrs_onln, schdlrs);
+					 "bad amount of schedulers %s\n",
+					 arg);
 			    erts_usage();
+			    break;
 			}
-			break;
-		    default:
-		    bad_S:
-			erts_fprintf(stderr,
-				     "bad amount of schedulers %s\n",
-				     arg);
-			erts_usage();
-			break;
-		    }
 
-		    VERBOSE(DEBUG_SYSTEM,
-			    ("using %d:%d scheduler(s)\n", tot, onln));
-		    break;
-		}
+			VERBOSE(DEBUG_SYSTEM,
+				("using %d:%d scheduler(s)\n", tot, onln));
+		    }
+                    break;
 		default:
 		    break;
 		}
 	    }
 	    i++;
 	}
+
+#ifdef ERTS_SMP
+	/* apply any scheduler percentages */
+	if (schdlrs_percentage != 100 || schdlrs_onln_percentage != 100) {
+	    schdlrs = schdlrs * schdlrs_percentage / 100;
+	    schdlrs_onln = schdlrs_onln * schdlrs_onln_percentage / 100;
+	    if (schdlrs < 1)
+                schdlrs = 1;
+            if (ERTS_MAX_NO_OF_SCHEDULERS < schdlrs) {
+		erts_fprintf(stderr,
+			     "bad schedulers percentage %d "
+			     "(total amount of schedulers %d)\n",
+			     schdlrs_percentage, schdlrs);
+		erts_usage();
+	    }
+	    if (schdlrs_onln < 1)
+                schdlrs_onln = 1;
+            if (schdlrs < schdlrs_onln) {
+		erts_fprintf(stderr,
+			     "bad schedulers online percentage %d "
+			     "(total amount of schedulers %d, online %d)\n",
+			     schdlrs_onln_percentage, schdlrs, schdlrs_onln);
+		erts_usage();
+	    }
+	}
+#endif
     }
 
 #ifndef USE_THREADS
@@ -1312,7 +1382,10 @@ erl_start(int argc, char **argv)
 	    break;
 
 	case 'S' : /* Was handled in early_init() just read past it */
-	    (void) get_arg(argv[i]+2, argv[i+1], &i);
+	    if (argv[i][2] == 'P')
+		(void) get_arg(argv[i]+3, argv[i+1], &i);
+	    else
+		(void) get_arg(argv[i]+2, argv[i+1], &i);
 	    break;
 
 	case 's' : {
diff --git a/erts/emulator/test/scheduler_SUITE.erl b/erts/emulator/test/scheduler_SUITE.erl
index 8931562828..81539faa09 100644
--- a/erts/emulator/test/scheduler_SUITE.erl
+++ b/erts/emulator/test/scheduler_SUITE.erl
@@ -52,6 +52,7 @@
 	 update_cpu_info/1,
 	 sct_cmd/1,
 	 sbt_cmd/1,
+	 scheduler_threads/1,
 	 scheduler_suspend/1,
 	 reader_groups/1]).
 
@@ -66,7 +67,7 @@ all() ->
      equal_with_part_time_max,
      equal_and_high_with_part_time_max, equal_with_high,
      equal_with_high_max, bound_process,
-     {group, scheduler_bind}, scheduler_suspend,
+     {group, scheduler_bind}, scheduler_threads, scheduler_suspend,
      reader_groups].
 
 groups() -> 
@@ -1039,7 +1040,66 @@ sbt_test(Config, CpuTCmd, ClBt, Bt, LP) ->
 		      tuple_to_list(SB)),
     ?line stop_node(Node),
     ?line ok.
-    
+
+scheduler_threads(Config) when is_list(Config) ->
+    SmpSupport = erlang:system_info(smp_support),
+    {Sched, SchedOnln, _} = get_sstate(Config, ""),
+    %% Configure half the number of both the scheduler threads and
+    %% the scheduler threads online.
+    {HalfSched, HalfSchedOnln} = case SmpSupport of
+                                     false -> {1,1};
+                                     true ->
+                                         {Sched div 2,
+                                          SchedOnln div 2}
+                                 end,
+    {HalfSched, HalfSchedOnln, _} = get_sstate(Config, "+SP 50:50"),
+    %% Use +S to configure 4x the number of scheduler threads and
+    %% 4x the number of scheduler threads online, but alter that
+    %% setting using +SP to 50% scheduler threads and 25% scheduler
+    %% threads online. The result should be 2x scheduler threads and
+    %% 1x scheduler threads online.
+    TwiceSched = case SmpSupport of
+                     false -> 1;
+                     true -> Sched*2
+                 end,
+    FourSched = integer_to_list(Sched*4),
+    FourSchedOnln = integer_to_list(SchedOnln*4),
+    CombinedCmd1 = "+S "++FourSched++":"++FourSchedOnln++" +SP50:25",
+    {TwiceSched, SchedOnln, _} = get_sstate(Config, CombinedCmd1),
+    %% Now do the same test but with the +S and +SP options in the
+    %% opposite order, since order shouldn't matter.
+    CombinedCmd2 = "+SP50:25 +S "++FourSched++":"++FourSchedOnln,
+    {TwiceSched, SchedOnln, _} = get_sstate(Config, CombinedCmd2),
+    %% Apply two +SP options to make sure the second overrides the first
+    TwoCmd = "+SP 25:25 +SP 100:100",
+    {Sched, SchedOnln, _} = get_sstate(Config, TwoCmd),
+    %% Configure 50% of scheduler threads online only
+    {Sched, HalfSchedOnln, _} = get_sstate(Config, "+SP:50"),
+    %% Configure 2x scheduler threads only
+    {TwiceSched, SchedOnln, _} = get_sstate(Config, "+SP 200"),
+    %% Test resetting the scheduler counts
+    ResetCmd = "+S "++FourSched++":"++FourSchedOnln++" +S 0:0",
+    {Sched, SchedOnln, _} = get_sstate(Config, ResetCmd),
+    %% Test negative +S settings, but only for SMP-enabled emulators
+    case SmpSupport of
+        false -> ok;
+        true ->
+            SchedMinus1 = Sched-1,
+            SchedOnlnMinus1 = SchedOnln-1,
+            {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1"),
+            {Sched, SchedOnlnMinus1, _} = get_sstate(Config, "+S :-1"),
+            {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1:-1")
+    end,
+    ok.
+
+get_sstate(Config, Cmd) ->
+    {ok, Node} = start_node(Config, Cmd),
+    [SState] = mcall(Node, [fun () ->
+                                    erlang:system_info(schedulers_state)
+                            end]),
+    stop_node(Node),
+    SState.
+
 scheduler_suspend(Config) when is_list(Config) ->
     ?line Dog = ?t:timetrap(?t:minutes(5)),
     ?line lists:foreach(fun (S) -> scheduler_suspend_test(Config, S) end,
diff --git a/erts/etc/common/erlexec.c b/erts/etc/common/erlexec.c
index f61d6cdbd3..c82797afc8 100644
--- a/erts/etc/common/erlexec.c
+++ b/erts/etc/common/erlexec.c
@@ -803,7 +803,6 @@ int main(int argc, char **argv)
 		  case 'n':
 		  case 'P':
 		  case 'Q':
-		  case 'S':
 		  case 't':
 		  case 'T':
 		  case 'R':
@@ -818,6 +817,19 @@ int main(int argc, char **argv)
 		      add_Eargs(argv[i+1]);
 		      i++;
 		      break;
+		  case 'S':
+		      if (argv[i][2] == 'P') {
+			  if (argv[i][3] != '\0')
+			      goto the_default;
+		      } else if (argv[i][2] != '\0')
+			  goto the_default;
+		      if (i+1 >= argc)
+			  usage(argv[i]);
+		      argv[i][0] = '-';
+		      add_Eargs(argv[i]);
+		      add_Eargs(argv[i+1]);
+		      i++;
+		      break;
 		  case 'B':
 		      argv[i][0] = '-';
 		      if (argv[i][2] != '\0') {
@@ -1119,7 +1131,9 @@ usage_aux(void)
 	  "[+l] [+M<SUBSWITCH> <ARGUMENT>] [+P MAX_PROCS] [+Q MAX_PORTS] "
 	  "[+R COMPAT_REL] "
 	  "[+r] [+rg READER_GROUPS_LIMIT] [+s SCHEDULER_OPTION] "
-	  "[+S NO_SCHEDULERS:NO_SCHEDULERS_ONLINE] [+T LEVEL] [+V] [+v] "
+	  "[+S NO_SCHEDULERS:NO_SCHEDULERS_ONLINE] "
+	  "[+SP PERCENTAGE_SCHEDULERS:PERCENTAGE_SCHEDULERS_ONLINE] "
+	  "[+T LEVEL] [+V] [+v] "
 	  "[+W<i|w>] [+z MISC_OPTION] [args ...]\n");
   exit(1);
 }