Items tagged with timing

This post is about the relationship between the number of processors used in parallel processing with the Threads package and the resultant real times and cpu times for a computation.

In the worksheet below, I perform the same computation using each possible number of processors on my machine, one thru eight. The computation is adding a list of 32 million pre-selected random integers. The real times and cpu times are collected from each run, and these are analyzed with a variety of metrics that I devised. Note that garbage-collection (gc) time is not an issue in the timings; as you can see below, the gc times are zero throughout.

My conclusion is that there are severely diminishing returns as the number of processors increases. There is a major benefit in going from one processor to two; there is a not-as-great-but-still-substantial benefit in going from two processors to four. But the real-time reduction in going from four processors to eight is very small compared to the substantial increase in resource consumption.

Please discuss the relevance of my six metrics, the soundness of my test technique, and how the presentation could be better. If you have a computer capable of running more than eight threads, please modify and run my worksheet on it.

Diminishing Returns from Parallel Processing: Is it worth using more than four processors with Threads?

Author: Carl J Love, 2016-July-30 

Set up tests

 

restart:

currentdir(kernelopts(homedir)):
if kernelopts(numcpus) <> 8 then
     error "This worksheet needs to be adjusted for your number of CPUs."
end if:
try fremove("ThreadsData.m") catch: end try:
try fremove("ThreadsTestData.m") catch: end try:
try fremove("ThreadsTest.mpl") catch: end try:

#Create and save random test data
L:= RandomTools:-Generate(list(integer, 2^25)):
save L, "ThreadsTestData.m":

#Create code file to be read for the tests.
fd:= FileTools:-Text:-Open("ThreadsTest.mpl", create):
fprintf(
     fd,
     "gc();\n"
     "read \"ThreadsTestData.m\":\n"
     "CodeTools:-Usage(Threads:-Add(x, x= L)):\n"
     "fd:= FileTools:-Text:-Open(\"ThreadsData.m\", create, append):\n"
     "fprintf(\n"
     "     fd, \"%%m%%m%%m\\n\",\n"
     "     kernelopts(numcpus),\n"
     "     CodeTools:-Usage(\n"
     "          Threads:-Add(x, x= L),\n"
     "          iterations= 8,\n"
     "          output= [realtime, cputime]\n"
     "     )\n"
     "):\n"
     "fclose(fd):"
):
fclose(fd):

#Code review
fd:= FileTools:-Text:-Open("ThreadsTest.mpl"):
while not feof(fd) do
     printf("%s\n", FileTools:-Text:-ReadLine(fd))
end do:

fclose(fd):

gc();
read "ThreadsTestData.m":
CodeTools:-Usage(Threads:-Add(x, x= L)):
fd:= FileTools:-Text:-Open("ThreadsData.m", create, append):
fprintf(
     fd, "%m%m%m\n",
     kernelopts(numcpus),
     CodeTools:-Usage(
          Threads:-Add(x, x= L),
          iterations= 8,
          output= [realtime, cputime]
     )
):
fclose(fd):

 

Run the tests

restart:

kernelopts(numcpus= 1):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.79MiB, alloc change=0 bytes, cpu time=2.66s, real time=2.66s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=2.26s, real time=2.26s, gc time=0ns

 

Repeat above test using numcpus= 2..8.

 

restart:

kernelopts(numcpus= 2):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.79MiB, alloc change=2.19MiB, cpu time=2.73s, real time=1.65s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=2.37s, real time=1.28s, gc time=0ns

 

restart:

kernelopts(numcpus= 3):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.79MiB, alloc change=4.38MiB, cpu time=2.98s, real time=1.38s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=2.75s, real time=1.05s, gc time=0ns

 

restart:

kernelopts(numcpus= 4):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.80MiB, alloc change=6.56MiB, cpu time=3.76s, real time=1.38s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=3.26s, real time=959.75ms, gc time=0ns

 

restart:

kernelopts(numcpus= 5):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.80MiB, alloc change=8.75MiB, cpu time=4.12s, real time=1.30s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=3.74s, real time=910.88ms, gc time=0ns

 

restart:

kernelopts(numcpus= 6):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.81MiB, alloc change=10.94MiB, cpu time=4.59s, real time=1.26s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=4.29s, real time=894.00ms, gc time=0ns

 

restart:

kernelopts(numcpus= 7):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.81MiB, alloc change=13.12MiB, cpu time=5.08s, real time=1.26s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=4.63s, real time=879.00ms, gc time=0ns

 

restart:

kernelopts(numcpus= 8):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.82MiB, alloc change=15.31MiB, cpu time=5.08s, real time=1.25s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=4.69s, real time=845.75ms, gc time=0ns

 

Analyze the data

restart:

currentdir(kernelopts(homedir)):

(R,C):= 'Vector(kernelopts(numcpus))' $ 2:
N:= Vector(kernelopts(numcpus), i-> i):

fd:= FileTools:-Text:-Open("ThreadsData.m"):
while not feof(fd) do
     (n,Tr,Tc):= fscanf(fd, "%m%m%m\n")[];
     (R[n],C[n]):= (Tr,Tc)
end do:

fclose(fd):

plot(
     (V-> <N | 100*~V>)~([R /~ max(R), C /~ max(C)]),
     title= "Raw timing data (normalized)",
     legend= ["real", "CPU"],
     labels= [`number of processors\n`, `%  of  max`],
     labeldirections= [HORIZONTAL,VERTICAL],
     view= [DEFAULT, 0..100]
);

The metrics:

 

R[1] /~ R /~ N:          Gain: The gain from parallelism expressed as a percentage of the theoretical maximum gain given the number of processors

C /~ R /~ N:               Evenness: How evenly the task is distributed among the processors

1 -~ C[1] /~ C:           Overhead: The percentage of extra resource consumption due to parallelism

R /~ R[1]:                   Reduction: The percentage reduction in real time

1 -~ R[2..] /~ R[..-2]:  Marginal Reduction: Percentage reduction in real time by using one more processor

C[2..] /~ C[..-2] -~ 1:  Marginal Consumption: Percentage increase in resource consumption by using one more processor

 

plot(
     [
          (V-> <N | 100*~V>)~([
               R[1]/~R/~N,             #gain from parallelism
               C/~R/~N,                #how evenly distributed
               1 -~ C[1]/~C,           #overhead
               R/~R[1]                 #reduction
          ])[],
          (V-> <N[2..] -~ .5 | 100*~V>)~([
               1 -~ R[2..]/~R[..-2],   #marginal reduction rate
               C[2..]/~C[..-2] -~ 1    #marginal consumption rate        
          ])[]
     ],
     legend= typeset~([
          'r[1]/r/n',
          'c/r/n',
          '1 - c[1]/c',
          'r/r[1]',
          '1 - `Delta__%`(r)',
          '`Delta__%`(c) - 1'       
     ]),
     linestyle= ["solid"$4, "dash"$2], thickness= 2,
     title= "Efficiency metrics\n", titlefont= [HELVETICA,BOLD,16],
     labels= [`number of processors\n`, `% change`], labelfont= [TIMES,ITALIC,14],
     labeldirections= [HORIZONTAL,VERTICAL],
     caption= "\nr = real time,  c = CPU time,  n = # of processors",
     size= combinat:-fibonacci~([16,15]),
     gridlines
);

 

 

Download Threads_dim_ret.mw

 

DEAR SIR

ANYONE CAN HELP TO COMPUTE TIME IN DSOLVE COMMAND?

restart

with(plots)

Nb := 0.1e-4; Nt := 0.1e-4; Sc := 3.0; Sb := 15; Pe := 1; Bi := .5; Pr := 6.8; c[4] := 0; c[6] := .3; c[8] := .4; k[1] := 0; k[2] := 1; k[3] := 0; Un := .1; M := .5

Eq1 := (101-100*lambda)*(1+c[2]*phi(eta))*(diff(f(eta), `$`(eta, 3)))+(diff(f(eta), `$`(eta, 2)))*(f(eta)+g(eta)+c[2]*(diff(phi(eta), eta)))-(diff(f(eta), eta))^2-M*(diff(f(eta), eta)-k[2])+k[2]+Un*(k[2]-(1/2)*eta*(diff(f(eta), `$`(eta, 2)))-(diff(f(eta), eta))) = 0

(101-100*lambda)*(1+c[2]*phi(eta))*(diff(diff(diff(f(eta), eta), eta), eta))+(diff(diff(f(eta), eta), eta))*(f(eta)+g(eta)+c[2]*(diff(phi(eta), eta)))-(diff(f(eta), eta))^2-.6*(diff(f(eta), eta))+1.6-0.5000000000e-1*eta*(diff(diff(f(eta), eta), eta)) = 0

(1)

Eq2 := (101-100*lambda)*(1+c[2]*phi(eta))*(diff(g(eta), `$`(eta, 3)))+(diff(g(eta), `$`(eta, 2)))*(f(eta)+g(eta)+c[2]*(diff(phi(eta), eta)))-(diff(g(eta), eta))^2-M*(diff(g(eta), eta)-k[2])+k[2]+Un*(k[2]-(1/2)*eta*(diff(g(eta), `$`(eta, 2)))-(diff(g(eta), eta))) = 0

(101-100*lambda)*(1+c[2]*phi(eta))*(diff(diff(diff(g(eta), eta), eta), eta))+(diff(diff(g(eta), eta), eta))*(f(eta)+g(eta)+c[2]*(diff(phi(eta), eta)))-(diff(g(eta), eta))^2-.6*(diff(g(eta), eta))+1.6-0.5000000000e-1*eta*(diff(diff(g(eta), eta), eta)) = 0

(2)

Eq3 := (1+c[4]*phi(eta))*(diff(theta(eta), `$`(eta, 2)))+Pr*(diff(theta(eta), eta))*(f(eta)+g(eta))+Nb*Pr*(diff(theta(eta), eta))*(diff(phi(eta), eta))*(1+c[6]*(2*phi(eta)+1))+Nt*Pr*(diff(theta(eta), eta))^2+c[4]*(diff(theta(eta), eta))*(diff(phi(eta), eta))-(1/2)*Pr*eta*Un*(diff(theta(eta), eta)) = 0

diff(diff(theta(eta), eta), eta)+6.8*(diff(theta(eta), eta))*(f(eta)+g(eta))+0.68e-4*(diff(theta(eta), eta))*(diff(phi(eta), eta))*(1.3+.6*phi(eta))+0.68e-4*(diff(theta(eta), eta))^2-.3400000000*eta*(diff(theta(eta), eta)) = 0

(3)

Eq4 := (1+c[6]*phi(eta))*(diff(phi(eta), `$`(eta, 2)))+Sc*(f(eta)+g(eta))*(diff(phi(eta), eta))+c[6]*(diff(phi(eta), eta))^2+Nt*(diff(theta(eta), `$`(eta, 2)))/Nb-(1/2)*Sc*eta*Un*(diff(phi(eta), eta)) = 0

(1+.3*phi(eta))*(diff(diff(phi(eta), eta), eta))+3.0*(f(eta)+g(eta))*(diff(phi(eta), eta))+.3*(diff(phi(eta), eta))^2+1.000000000*(diff(diff(theta(eta), eta), eta))-.1500000000*eta*(diff(phi(eta), eta)) = 0

(4)

Eq5 := (1+c[8]*phi(eta))*(diff(chi(eta), `$`(eta, 2)))+c[8]*(diff(phi(eta), eta))*(diff(chi(eta), eta))-Pe*(chi(eta)*(diff(phi(eta), `$`(eta, 2)))+(diff(phi(eta), eta))*(diff(chi(eta), eta)))+Sb*(diff(chi(eta), eta))*(f(eta)+g(eta))-(1/2)*Sb*eta*Un*(diff(chi(eta), eta)) = 0

(1+.4*phi(eta))*(diff(diff(chi(eta), eta), eta))-.6*(diff(phi(eta), eta))*(diff(chi(eta), eta))-chi(eta)*(diff(diff(phi(eta), eta), eta))+15*(diff(chi(eta), eta))*(f(eta)+g(eta))-.7500000000*eta*(diff(chi(eta), eta)) = 0

(5)

Vc[2] := [.2, .3, .4]

etainf := 1.85

bcs := (D(f))(0) = k[1], (D(g))(0) = k[3], f(0) = 0, g(0) = 0, (D(theta))(0) = -Bi*(1-theta(0))/(1+c[4]*phi(0)), Nb*(D(phi))(0)*(1+c[6]*(2*phi(0)+1))+Nt*(D(theta))(0) = 0, chi(0) = 1, (D(f))(etainf) = k[2], (D(g))(etainf) = k[2], theta(etainf) = 0, phi(etainf) = 0, chi(etainf) = 0

(D(f))(0) = 0, (D(g))(0) = 0, f(0) = 0, g(0) = 0, (D(theta))(0) = -.5+.5*theta(0), 0.1e-4*(D(phi))(0)*(1.3+.6*phi(0))+0.1e-4*(D(theta))(0) = 0, chi(0) = 1, (D(f))(1.85) = 1, (D(g))(1.85) = 1, theta(1.85) = 0, phi(1.85) = 0, chi(1.85) = 0

(6)

dsys := {Eq1, Eq2, Eq3, Eq4, Eq5, bcs}

for i to 3 do c[2] := Vc[2][i]; dsol[i] := dsolve(dsys, numeric, continuation = lambda); print(c[2]); print(dsol[i](0)) end do

.2

 

[eta = 0., chi(eta) = HFloat(1.0), diff(chi(eta), eta) = HFloat(3.888290578689045), f(eta) = HFloat(0.0), diff(f(eta), eta) = HFloat(0.0), diff(diff(f(eta), eta), eta) = HFloat(2.244199282192492), g(eta) = HFloat(0.0), diff(g(eta), eta) = HFloat(0.0), diff(diff(g(eta), eta), eta) = HFloat(2.244199282192492), phi(eta) = HFloat(-2.044191234673432), diff(phi(eta), eta) = HFloat(5.227515304629519), theta(eta) = HFloat(0.2317093657771352), diff(theta(eta), eta) = HFloat(-0.38414531711143246)]

 

.3

 

[eta = 0., chi(eta) = HFloat(1.0), diff(chi(eta), eta) = HFloat(4.148187853914835), f(eta) = HFloat(0.0), diff(f(eta), eta) = HFloat(0.0), diff(diff(f(eta), eta), eta) = HFloat(3.1086884419918364), g(eta) = HFloat(0.0), diff(g(eta), eta) = HFloat(0.0), diff(diff(g(eta), eta), eta) = HFloat(3.1086884419918364), phi(eta) = HFloat(-2.049332060722701), diff(phi(eta), eta) = HFloat(5.527786294980874), theta(eta) = HFloat(0.2216792480031605), diff(theta(eta), eta) = HFloat(-0.38916037599841974)]

 

.4

 

[eta = 0., chi(eta) = HFloat(0.9999999999999998), diff(chi(eta), eta) = HFloat(4.580796631072469), f(eta) = HFloat(0.0), diff(f(eta), eta) = HFloat(0.0), diff(diff(f(eta), eta), eta) = HFloat(5.687607599246298), g(eta) = HFloat(0.0), diff(g(eta), eta) = HFloat(0.0), diff(diff(g(eta), eta), eta) = HFloat(5.687607599246298), phi(eta) = HFloat(-2.0568809171520708), diff(phi(eta), eta) = HFloat(6.0203396482123575), theta(eta) = HFloat(0.20686299926628238), diff(theta(eta), eta) = HFloat(-0.39656850036685887)]

(7)

NULL

 

 

Download 3DAKc2w_-_Copy.mw

For reference this question was posted exactly 9:05

A simple timing program

st:=time():
for i to 35 do
  i;
end do;
time()-st;

On M16 seems to display after 7 seconds, the time reads 0.010
On M12 it displays in roughly 2 seconds with the time as 0.170

It is physically longer with M16.  Do others get the same results?

**edit add**
No comments?  I should add that it is a laptop 1.4Ghz single core.  Not that it matters but maybe M16 is set up to work more efficiently...

Page 1 of 1