Re: an example of parallel calculation of metrics

[Jay Norwood via Digitalmars-d-learn]

On Thursday, 1 October 2015 at 18:08:31 UTC, Ali Çehreli wrote:
However, if you prove to yourself that the result tuple and 
your struct have the same memory layout, you can cast the tuple 
slice to struct slice after calling amap:

After re-reading your explanation, I see that the problem is only 
that the results needs to be a Tuple.  It works with named tuple 
members in this example as the result and array of struct as the 
input.  I'll re-check if the multi-member result also works with 
named members.  I'll update the issue report.

import std.meta;
import std.stdio;

// define some input measurement sample tuples and output metric 
tuples

struct TI {long L1I_MISS; long L1D_MISS; }
alias TO = Tuple!(long, "raw");

// various metric definitions
// using Tuples with defined names for each member, and use the 
names here in the metrics.
TO met_l1_miss ( ref TI m){ TO rv;  rv.raw = 
m.L1I_MISS+m.L1D_MISS; return rv; }

// a convenience to use all the metrics above as a list
alias Metrics = AliasSeq!(met_l1_miss);

void main(string[] argv)
{
        auto samples = iota(100);
        auto meas = new TI[samples.length];
        auto results = new TO[samples.length];

        // Initialize some values for the measured samples
        foreach(i, ref m; meas){
                m.L1D_MISS= 100+i; m.L1I_MISS=100-i;
        }

    ref TI getTerm(int i)
    {
        return meas[i];
    }

	// compute the metric results for the above measured sample 
values in parallel
        taskPool.amap!(Metrics)(std.algorithm.map!getTerm(samples),results);

        TO rv1 = met_l1_miss( meas[1]);

        writeln("measurements:", meas[1]);
        writeln("rv1:", rv1);
        writeln("results:", results[1]);

}