This is another attempt with the metric parallel processing. This uses the results only to return an int value, which could be used later as an error return value.  The metric value locations are now allocated as a part of the input measurement values tuple.

The Tuple vs struct definitions seem to have a big difference in default output formatting.


import std.algorithm, std.parallelism, std.range;
import std.typecons;
import std.meta;
import std.stdio;

// define some input measurement sample tuples and output metric tuples
alias TR = Tuple!(long,"raw",double, "per_cycle");
//struct TR {long raw; double per_cycle;}
alias TO = Tuple!(TR, "l1_miss", TR, "l1_access" );
//struct TO {TR l1_miss; TR l1_access; };
alias TI = Tuple!(long, "L1I_MISS",long, "L1D_MISS", long, "L1D_READ", long, "L1D_WRITE", long, "cycles", TO, "res");

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

int met_all (ref TI m) {

	with (m.res){
	 l1_miss.raw = met_l1_miss(m);
	 l1_access.raw = met_l1_access(m);
	 l1_miss.per_cycle =  (m.cycles == 0)? double.nan : l1_miss.raw / cast(double)m.cycles;
	 l1_access.per_cycle = (m.cycles == 0)? double.nan : l1_access.raw / cast(double)m.cycles;
	}
	return 0;
}

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

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

	// Initialize some values for the measured samples
	foreach(i, ref m; meas){
		m.L1D_MISS= 100+i; m.L1I_MISS=100-i;
		m.L1D_READ= 200+i; m.L1D_WRITE=200-i;
		m.cycles= 10+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);


	writeln("measurements:", meas[1]);
	foreach(ref m; meas){
		writeln(m.res);
	}

}