From a0e6ddd51992f6644f1fbb9ad10ac1a90d8a7384 Mon Sep 17 00:00:00 2001 From: hsc Date: Mon, 12 Nov 2012 13:55:45 +0000 Subject: [PATCH] ecos: fault-space cutoff specific for this campaign For the eCos kernel test campaign we define a relatively "special" metric to compare FI results from different applications: Instead of aligning the fault-space dimensions (e.g., by artificially adding "don't care" space to the right for shorter application variants), we only keep the data address axis constant. The rationale behind this is that -- despite the benchmark applications' run-to-completion behavior -- an operating system's scheduler usually runs ad infinitum, and that we therefore can extrapolate from a short application run to any longer period. In essence, this means we use a failure/experiment-length quotient (ignoring the Y axis for simplicity, as it is constant in size) to compare application variants, instead of an absolute failure count. One important side effect is that we do not punish any application slowdown with this metric. (And simply prolongating non-susceptible program sections with, e.g., NOPs, seemingly "improves" fault tolerance.) git-svn-id: https://www4.informatik.uni-erlangen.de/i4svn/danceos/trunk/devel/fail@1922 8c4709b5-6ec9-48aa-a5cd-a96041d1645a --- src/experiments/ecos_kernel_test/campaign.cc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/experiments/ecos_kernel_test/campaign.cc b/src/experiments/ecos_kernel_test/campaign.cc index c3851f53..8096e235 100644 --- a/src/experiments/ecos_kernel_test/campaign.cc +++ b/src/experiments/ecos_kernel_test/campaign.cc @@ -201,6 +201,8 @@ bool EcosKernelTestCampaign::run() // instruction counter within trace unsigned instr = 0; + // "rightmost" instr where we did a FI experiment + unsigned instr_rightmost = 0; // fill open_ecs with one EC for every address for (MemoryMap::iterator it = mm.begin(); it != mm.end(); ++it) { @@ -247,6 +249,7 @@ bool EcosKernelTestCampaign::run() // a sequence ending with READ: we need to do one experiment to // cover it completely add_experiment_ec(variant, benchmark, data_address, instr1, instr2, instr_absolute); + instr_rightmost = instr2; } else if (ev.accesstype() == ev.WRITE) { // a sequence ending with WRITE: an injection anywhere here // would have no effect. @@ -267,12 +270,17 @@ bool EcosKernelTestCampaign::run() address_t data_address = lastuse_it->first; int instr1 = lastuse_it->second; +#if 0 // Why -1? In most cases it does not make sense to inject before the // very last instruction, as we won't execute it anymore. This *only* // makes sense if we also inject into parts of the result vector. This // is not the case in this experiment, and with -1 we'll get a result // comparable to the non-pruned campaign. int instr2 = instr - 1; +#else + // EcosKernelTestCampaign only variant: fault space ends with the last FI experiment + int instr2 = instr_rightmost; +#endif int instr_absolute = 0; // unknown // zero-sized? skip. @@ -299,6 +307,7 @@ bool EcosKernelTestCampaign::run() m_log << variant << "/" << benchmark << " exp " << (count_exp - local_count_exp) << " (" << (count_exp_jobs - local_count_exp_jobs) << " jobs)" << " known " << (count_known - local_count_known) << " (" << (count_known_jobs - local_count_known_jobs) << " jobs)" + << " faultspace cutoff @ " << instr_rightmost << " out of " << instr << endl; } }