695240_de-DE

liliconcom

Ist For Each() besser als Parallel Assign()?

Hier ist eine interessante Frage für die Programmierer unter uns.

Ich habe zwei Varianten einer Simulation, die ich ausführe. Der Algorithmus ist identisch, außer dass einer eine For Each()-Schleife verwendet und der andere Parallel Assign ausführt. Die For Each-Schleife benötigt durchweg viel weniger Zeit, um denselben Berechnungssatz durchzuführen wie die Parallel Assign, selbst wenn alle 8 meiner Kerne ausgelastet sind.  

 

Hat jemand eine Idee, woran das liegen könnte? Der Code für jede Version der Simulation ist unten:

Parallele Zuweisungsversion

// JSL Code for Simulation of Harmonized Compendial Dissolution Criteria USP <711>

// Simulation function for USP dissolution - three stage test
// reps =   number of simulated lots for simulation
// mean =   the process mean
// sd =     the process standard deviation
// Q =      value as specified in the mongraph for the product
//
// Summary Matrix Key
// ==================
// 1 "PassS1"
// 2 "PassS2" 
// 3 "PassS3"
// 4 "#<Q s1="">= Q & sum_matrix[i, 7] == 0,
     sum_matrix[i, 2] = 1;
     sum_matrix[i, 12] = 1;
     sum_matrix[i, 14] = 0;
    ,
     sum_matrix[i, 2] = 0;
     If( sum_matrix[i, 7] <= 2 & sum_matrix[i, 8] == 0,
      sum_matrix[i, 14] = 1,
      sum_matrix[i, 14] = 0;
      sum_matrix[i, 12] = 0;
     );
    )
   );
    
   // Stage 3
   If( sum_matrix[i, 14] == 1,
    If( sum_matrix[i, 9] >= Q & sum_matrix[i, 10] <= 2 & sum_matrix[i, 11] == 0,
     sum_matrix[i, 3] = 1;
     sum_matrix[i, 12] = 1;
    ,
     sum_matrix[i, 3] = 0;
     sum_matrix[i, 12] = 0;
    )
   );
  );
 
  // return the value
  Mean( sum_matrix[0, 12] );
 )},
 simMat[a, b] = simDissoTest( repN, 80 + cs[1] + cs[3] * (b - 1), a * rs[3] )
);
stop = Tick Seconds();
time = stopWatch( start, stop, "min" );
Show( time, ntests );</Q>

Für jede () Version

// JSL Code for Simulation of Harmonized Compendial Dissolution Criteria USP <711>


// Simulation function for USP dissolution - three stage test
// reps =   number of simulated lots for simulation
// mean =   the process mean
// sd =     the process standard deviation
// Q =      value as specified in the mongraph for the product
//
// Summary Matrix Key
// ==================
// 1 "PassS1"
// 2 "PassS2" 
// 3 "PassS3"
// 4 "#<Q s1="">= Q & sum_matrix[i, 7] == 0,
    sum_matrix[i, 2] = 1;
    sum_matrix[i, 12] = 1;
    sum_matrix[i, 14] = 0;
   ,
    sum_matrix[i, 2] = 0;
    If( sum_matrix[i, 7] <= 2 & sum_matrix[i, 8] == 0,
     sum_matrix[i, 14] = 1,
     sum_matrix[i, 14] = 0;
     sum_matrix[i, 12] = 0;
    );
   )
  );
    
   // Stage 3
  If( sum_matrix[i, 14] == 1,
   If( sum_matrix[i, 9] >= Q & sum_matrix[i, 10] <= 2 & sum_matrix[i, 11] == 0,
    sum_matrix[i, 3] = 1;
    sum_matrix[i, 12] = 1;
   ,
    sum_matrix[i, 3] = 0;
    sum_matrix[i, 12] = 0;
   )
  );
 );
 
  // return the value
 Mean( sum_matrix[0, 12] );
);


//---------------------------------------------------------------------------------
// Parallelized Simulation
//---------------------------------------------------------------------------------
// define the size of the matrix ans the step size
rows = vecSize( 0.1, 12, 0.1 );
rowShape = [0.1, 12, 0.1];
cols = vecSize( -1, 10, 0.5 );
colShape = [-1, 10, 0.5];
reps = 100;
ntests = rows * cols;

//create the Parallel test matrix
simMat = J( rows, cols, Empty() );

// run the simulation (testing scalability)
//New Window( "test", lb = Lineup Box( N Col( 2 ) ) );

/*For Each( {repN, i}, {1, 50, 100, 500},
 start = Tick Seconds();
 For Each( {v, {i, j}}, simMat,
  simMat[i, j] = simDissoTest( repN, 80 + colShape[1] + colShape[3] * (j - 1), i * rowShape[3] )
 );
 stop = Tick Seconds();
 time = stopWatch( start, stop, "min" );
 Show( repN, time, ntests );

 //lb << Append( V List Box( Text Box( "Number of reps: " || Char( repN ) ), New Heat Image( simMat ) ) );
);*/

// run the simulation 
start = Tick Seconds();
For Each( {v, {i, j}}, simMat,
 simMat[i, j] = simDissoTest( reps, 80 + colShape[1] + colShape[3] * (j - 1), i * rowShape[3] )
);
stop = Tick Seconds();
time = stopWatch( start, stop, "min" );
Show( reps, time, ntests );

// make the data table from the matrix
tallMatrix = J( ntests, 3, Empty() );
k = 1; // an indexer
For Each( {v, {i, j}}, simMat,
 tallMatrix[k, 1] = 80 + colShape[1] + colShape[3] * (j - 1);
 tallMatrix[k, 2] = i * rowShape[3];
 tallMatrix[k, 3] = v;
 k++;
);

dt = As Table( tallMatrix );
Column( dt, 1 ) << Set Name( "Mean" );
Column( dt, 2 ) << Set Name( "Std Dev" );
Column( dt, 3 ) << Set Name( "Pass Rate" );

dt << New Script(
 "Graph",
 Graph Builder(
  Size( 742, 817 ),
  Show Control Panel( 0 ),
  Fit to Window,
  Variables( X( :Mean ), Y( :Std Dev ), Color( :Pass Rate ) ),
  Elements( Contour( X, Y, Legend( 6 ), Number of Levels( 5 ), Smoothness( 0.146217717445672 ) ) ),
  SendToReport(
   Dispatch(
    {},
    "Mean",
    ScaleBox,
    {Min( 79.0036098075223 ), Max( 89.9788461538462 ), Inc( 2 ), Minor Ticks( 1 )}
   ),
   Dispatch(
    {},
    "Std Dev",
    ScaleBox,
    {Min( 0.0888646043293861 ), Max( 11.971158234127 ), Inc( 2 ), Minor Ticks( 1 )}
   ),
   Dispatch(
    {},
    "400",
    ScaleBox,
    {Legend Model(
     6,
     Properties(
      0,
      {gradient(
       {Color Theme( "Green Yellow Red"(1) ), Scale Values( [0.8 .] ),
       Reverse Gradient( 1 )}
      )},
      Item ID( "Pass Rate", 1 )
     )
    )}
   )
  )
 )
);

dt << Run Script("Graph");

disclaimer;</Q>

Betreff: Ist For Each() besser als Parallel Assign()??

Hallo Mike,

Ich gebe zu, dass ich nur einen kurzen Scan des Codes durchgeführt habe, aber geben Sie 1000 Wiederholungen für die parallele Version und nur 100 Wiederholungen für die For Each-Version an? (Obwohl die Funktion standardmäßig auf 100 Wiederholungen eingestellt ist, sieht es aufgrund von Zeile 58 so aus, als würden Sie 1000 auf die parallele Version übertragen.)

Als ich die Zeilen 58 und 321 verwendet habe, um 1, 10 und 100 Wiederholungen anzugeben (ich habe leider nicht die Geduld für 1000), waren die Ergebnisse bei 1 und 10 ähnlich, aber parallel ging es bei 100 schneller.

Dies erscheint mir sinnvoll, da etwaige Effizienzgewinne den Overhead des parallelen Thread-Setups erst ausgleichen, wenn die Aufgabe ausreichend groß ist.

-Brady

Betreff: Ist For Each() besser als Parallel Assign()??

@brady_brady - Ja, ich habe den Code für jeden dort hochgeladen, wo er war, als ich ihn das letzte Mal ausgeführt habe. Aber ich bemerkte den Trend, als ich den Code jeweils mit 10, 100, 1K und 10K Simulationen ausführte. Die Grafik oben zeigt die Tickzeiten. Ich überlege, den Test mit einem CPU-Logger erneut auszuführen, damit ich die tatsächlichen CPU-Auslastungen ermitteln kann. Ich hatte so etwas wie das erwartet, was Sie gesehen haben, aber die Ergebnisse, die ich erhielt, skalierten jedes Mal linear mit der Schleife an der Spitze.