christoph/fail
1
Fork 0
Code Actions Packages Releases Activity

Fail* directories reorganized, Code-cleanup (-> coding-style), Typos+comments fixed.

Browse Source 
git-svn-id: https://www4.informatik.uni-erlangen.de/i4svn/danceos/trunk/devel/fail@1321 8c4709b5-6ec9-48aa-a5cd-a96041d1645a
This commit is contained in:
adrian
2012-06-08 20:09:43 +00:00
parent d474a5b952
commit 2575604b41
866 changed files with 1848 additions and 1879 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/experiments/checksum-oostubs/CMakeLists.txt Normal file
View File

@ -0,0 +1,32 @@
set(EXPERIMENT_NAME checksum-oostubs)
set(EXPERIMENT_TYPE ChecksumOOStuBSExperiment)
configure_file(../instantiate-experiment.ah.in
${CMAKE_CURRENT_BINARY_DIR}/instantiate-${EXPERIMENT_NAME}.ah @ONLY
)
## Setup desired protobuf descriptions HERE ##
set(MY_PROTOS
checksum-oostubs.proto
)
set(MY_CAMPAIGN_SRCS
experiment.hpp
experiment.cc
campaign.hpp
campaign.cc
)
#### PROTOBUFS ####
find_package(Protobuf REQUIRED)
include_directories(${PROTOBUF_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_BINARY_DIR})
PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS ${MY_PROTOS})
## Build library
add_library(${EXPERIMENT_NAME} ${PROTO_SRCS} ${PROTO_HDRS} ${MY_CAMPAIGN_SRCS})
add_dependencies(${EXPERIMENT_NAME} tracing)
## This is the example's campaign server distributing experiment parameters
add_executable(${EXPERIMENT_NAME}-server main.cc)
target_link_libraries(${EXPERIMENT_NAME}-server ${EXPERIMENT_NAME} fail ${PROTOBUF_LIBRARY} ${Boost_THREAD_LIBRARY})

258
src/experiments/checksum-oostubs/campaign.cc Normal file
View File

@ -0,0 +1,258 @@
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include "campaign.hpp"
#include "experimentInfo.hpp"
#include "cpn/CampaignManager.hpp"
#include "util/Logger.hpp"
#include "util/ProtoStream.hpp"
#include "util/MemoryMap.hpp"
#include "ecc_region.hpp"
#include "../plugins/tracing/TracingPlugin.hpp"
char const * const trace_filename = "trace.pb";
using namespace std;
using namespace fail;
char const * const results_csv = "chksumoostubs.csv";
// equivalence class type: addr, [i1, i2]
// addr: byte to inject a bit-flip into
// [i1, i2]: interval of instruction numbers, counted from experiment
// begin
struct equivalence_class {
address_t data_address;
int instr1, instr2;
address_t instr2_absolute; // FIXME we could record them all here
};
bool ChecksumOOStuBSCampaign::run()
{
Logger log("ChecksumOOStuBS Campaign");
ifstream test(results_csv);
if (test.is_open()) {
log << results_csv << " already exists" << endl;
return false;
}
ofstream results(results_csv);
if (!results.is_open()) {
log << "failed to open " << results_csv << endl;
return false;
}
log << "startup" << endl;
// load trace
ifstream tracef(trace_filename);
if (tracef.fail()) {
log << "couldn't open " << trace_filename << endl;
return false;
}
ProtoIStream ps(&tracef);
// a map of addresses of ECC protected objects
MemoryMap mm;
for (unsigned i = 0; i < sizeof(memoryMap)/sizeof(*memoryMap); ++i) {
mm.add(memoryMap[i][0], memoryMap[i][1]);
}
// set of equivalence classes that need one (rather: eight, one for
// each bit in that byte) experiment to determine them all
vector<equivalence_class> ecs_need_experiment;
// set of equivalence classes that need no experiment, because we know
// they'd be identical to the golden run
vector<equivalence_class> ecs_no_effect;
equivalence_class current_ec;
// map for efficient access when results come in
map<ChecksumOOStuBSExperimentData *, unsigned> experiment_ecs;
// experiment count
int count = 0;
// XXX do it the other way around: iterate over trace, search addresses
// for every injection address ...
for (MemoryMap::iterator it = mm.begin(); it != mm.end(); ++it) {
cerr << ".";
address_t data_address = *it;
current_ec.instr1 = 0;
int instr = 0;
address_t instr_absolute = 0; // FIXME this one probably should also be recorded ...
Trace_Event ev;
ps.reset();
// for every section in the trace between subsequent memory
// accesses to that address ...
// XXX reorganizing the trace for efficient seeks could speed this up
while(ps.getNext(&ev)) {
// instruction events just get counted
if (!ev.has_memaddr()) {
// new instruction
instr++;
instr_absolute = ev.ip();
continue;
// skip accesses to other data
} else if (ev.memaddr() != data_address) {
continue;
// skip zero-sized intervals: these can
// occur when an instruction accesses a
// memory location more than once
// (e.g., INC, CMPXCHG)
} else if (current_ec.instr1 > instr) {
continue;
}
// we now have an interval-terminating R/W
// event to the memaddr we're currently looking
// at:
// complete the equivalence interval
current_ec.instr2 = instr;
current_ec.instr2_absolute = instr_absolute;
current_ec.data_address = data_address;
if (ev.accesstype() == ev.READ) {
// a sequence ending with READ: we need
// to do one experiment to cover it
// completely
ecs_need_experiment.push_back(current_ec);
// instantly enqueue jobs: that way the job clients can already
// start working in parallel
for (int bitnr = 0; bitnr < 8; ++bitnr) {
ChecksumOOStuBSExperimentData *d = new ChecksumOOStuBSExperimentData;
// we pick the rightmost instruction in that interval
d->msg.set_instr_offset(current_ec.instr2);
d->msg.set_instr_address(current_ec.instr2_absolute);
d->msg.set_mem_addr(current_ec.data_address);
d->msg.set_bit_offset(bitnr);
// store index into ecs_need_experiment
experiment_ecs[d] = ecs_need_experiment.size() - 1;
campaignmanager.addParam(d);
++count;
}
} else if (ev.accesstype() == ev.WRITE) {
// a sequence ending with WRITE: an
// injection anywhere here would have
// no effect.
ecs_no_effect.push_back(current_ec);
} else {
log << "WAT" << endl;
}
// next interval must start at next
// instruction; the aforementioned
// skipping mechanism wouldn't work
// otherwise
current_ec.instr1 = instr + 1;
}
// close the last interval:
// 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.
// XXX still true for checksum-oostubs?
current_ec.instr2 = instr - 1;
current_ec.instr2_absolute = 0; // won't be used
current_ec.data_address = data_address;
// zero-sized? skip.
if (current_ec.instr1 > current_ec.instr2) {
continue;
}
// as the experiment ends, this byte is a "don't care":
ecs_no_effect.push_back(current_ec);
}
campaignmanager.noMoreParameters();
log << "done enqueueing parameter sets (" << count << ")." << endl;
log << "equivalence classes generated:"
<< " need_experiment = " << ecs_need_experiment.size()
<< " no_effect = " << ecs_no_effect.size() << endl;
// statistics
unsigned long num_dumb_experiments = 0;
for (vector<equivalence_class>::const_iterator it = ecs_need_experiment.begin();
it != ecs_need_experiment.end(); ++it) {
num_dumb_experiments += (*it).instr2 - (*it).instr1 + 1;
}
for (vector<equivalence_class>::const_iterator it = ecs_no_effect.begin();
it != ecs_no_effect.end(); ++it) {
num_dumb_experiments += (*it).instr2 - (*it).instr1 + 1;
}
log << "pruning: reduced " << num_dumb_experiments * 8 <<
" experiments to " << ecs_need_experiment.size() * 8 << endl;
// CSV header
results << "ec_instr1\tec_instr2\tec_instr2_absolute\tec_data_address\tbitnr\tresulttype\tresult0\tresult1\tresult2\tfinish_reached\tlatest_ip\terror_corrected\tdetails" << endl;
// store no-effect "experiment" results
for (vector<equivalence_class>::const_iterator it = ecs_no_effect.begin();
it != ecs_no_effect.end(); ++it) {
results
<< (*it).instr1 << "\t"
<< (*it).instr2 << "\t"
<< (*it).instr2_absolute << "\t" // incorrect in all but one case!
<< (*it).data_address << "\t"
<< "99\t" // dummy value: we didn't do any real experiments
<< "1\t"
<< "99\t99\t99\t"
<< "1\t"
<< "99\t"
<< "0\t\n";
}
// collect results
ChecksumOOStuBSExperimentData *res;
int rescount = 0;
while ((res = static_cast<ChecksumOOStuBSExperimentData *>(campaignmanager.getDone()))) {
rescount++;
map<ChecksumOOStuBSExperimentData *, unsigned>::iterator it =
experiment_ecs.find(res);
if (it == experiment_ecs.end()) {
results << "WTF, didn't find res!" << endl;
log << "WTF, didn't find res!" << endl;
continue;
}
equivalence_class &ec = ecs_need_experiment[it->second];
// sanity check
if (ec.instr2 != res->msg.instr_offset()) {
results << "WTF" << endl;
log << "WTF" << endl;
//delete res; // currently racy if jobs are reassigned
}
results
<< ec.instr1 << "\t"
<< ec.instr2 << "\t"
<< ec.instr2_absolute << "\t" // incorrect in all but one case!
<< ec.data_address << "\t"
<< res->msg.bit_offset() << "\t"
<< res->msg.resulttype() << "\t"
<< res->msg.resultdata(0) << "\t"
<< res->msg.resultdata(1) << "\t"
<< res->msg.resultdata(2) << "\t"
<< res->msg.finish_reached() << "\t"
<< res->msg.latest_ip() << "\t"
<< res->msg.error_corrected() << "\t"
<< res->msg.details() << "\n";
//delete res; // currently racy if jobs are reassigned
}
log << "done. sent " << count << " received " << rescount << endl;
results.close();
return true;
}

19
src/experiments/checksum-oostubs/campaign.hpp Normal file
View File

@ -0,0 +1,19 @@
#ifndef __CHECKSUM_OOSTUBS_CAMPAIGN_HPP__
#define __CHECKSUM_OOSTUBS_CAMPAIGN_HPP__
#include "cpn/Campaign.hpp"
#include "comm/ExperimentData.hpp"
#include "checksum-oostubs.pb.h"
class ChecksumOOStuBSExperimentData : public fail::ExperimentData {
public:
OOStuBSProtoMsg msg;
ChecksumOOStuBSExperimentData() : fail::ExperimentData(&msg) {}
};
class ChecksumOOStuBSCampaign : public fail::Campaign {
public:
virtual bool run();
};
#endif // __CHECKSUM_OOSTUBS_CAMPAIGN_HPP__

42
src/experiments/checksum-oostubs/checksum-oostubs.proto Normal file
View File

@ -0,0 +1,42 @@
message OOStuBSProtoMsg {
// Input: experiment parameters
required int32 instr_offset = 1;
optional int32 instr_address = 2; // for sanity checks
required int32 mem_addr = 3;
required int32 bit_offset = 4;
// ----------------------------------------------------
// Output: experiment results
// (make these optional to reduce overhead for server->client communication)
// instruction pointer where injection was done
optional uint32 injection_ip = 5;
// result type:
// FINISHED = planned number of instructions were executed
// TRAP = premature guest "crash"
enum ResultType {
FINISHED = 1;
TRAP = 2;
HALT = 3;
UNKNOWN = 4;
}
optional ResultType resulttype = 6;
// result details:
// resultdata = result[0-2]
repeated uint32 resultdata = 7 [packed=true];
// was finish() ever reached?
optional bool finish_reached = 8;
// especially interesting for TRAP/ UNKNOWN: latest IP
optional uint32 latest_ip = 9;
// did ECC correct the fault?
optional int32 error_corrected = 10;
// optional textual description of what happened
optional string details = 11;
}

74
src/experiments/checksum-oostubs/ecc_region.hpp Normal file
View File

@ -0,0 +1,74 @@
// generated from STEP 0 output with region2array.sh
static const unsigned memoryMap[][2] = {
{0x10b338, 89},
{0x10b394, 89},
{0x10b3f0, 89},
{0x10b44c, 13},
{0x10b45c, 13},
{0x10c408, 4},
{0x10c410, 4},
{0x10c448, 4},
{0x10c4e4, 256},
{0x10c5f8, 4},
{0x10c604, 4},
{0x10c608, 4},
{0x10c61c, 1},
{0x10c63c, 1},
{0x10c648, 1},
{0x10c649, 1},
{0x10c64a, 1},
{0x10c64b, 1},
{0x10c64c, 1},
{0x10c651, 1},
{0x10c654, 4},
{0x10c65c, 4},
{0x10c668, 1},
{0x10c668, 1},
{0x10c668, 1},
{0x10c669, 1},
{0x10c669, 1},
{0x10c669, 1},
{0x10c66a, 1},
{0x10c66a, 1},
{0x10c66a, 1},
{0x10c66f, 1},
{0x10c670, 1},
{0x10c671, 1},
{0x10c67c, 4},
{0x10c680, 4},
{0x10c688, 4},
{0x10c698, 4},
{0x10c6a4, 4},
{0x10c6a8, 4},
{0x10c6b0, 1},
{0x10c6b8, 4},
{0x10c6bc, 4},
{0x10d6c4, 4},
{0x10d6cc, 4},
{0x10d6d4, 4},
{0x10d6dc, 4},
{0x10d6f4, 4},
{0x10d6fc, 4},
{0x10d70c, 1},
{0x10d720, 4},
{0x10d724, 4},
{0x10d734, 4},
{0x10d739, 1},
{0x10d740, 4},
{0x10d744, 4},
{0x10d754, 4},
{0x10d759, 1},
{0x10d760, 4},
{0x10d764, 4},
{0x10d774, 4},
{0x10d779, 1},
{0x10d780, 4},
{0x10d784, 4},
{0x10d78c, 4},
{0x110618, 4},
{0x110620, 4},
{0x110644, 4},
{0x11064c, 4},
{0x110670, 4},
{0x110678, 4},
};

282
src/experiments/checksum-oostubs/experiment.cc Normal file
View File

@ -0,0 +1,282 @@
#include <iostream>
#include <fstream>
// getpid
#include <sys/types.h>
#include <unistd.h>
#include "util/Logger.hpp"
#include "experiment.hpp"
#include "experimentInfo.hpp"
#include "campaign.hpp"
#include "sal/SALConfig.hpp"
#include "sal/SALInst.hpp"
#include "sal/Memory.hpp"
#include "sal/bochs/BochsRegister.hpp"
#include "sal/Event.hpp"
// You need to have the tracing plugin enabled for this
#include "../plugins/tracing/TracingPlugin.hpp"
#include "ecc_region.hpp"
using namespace std;
using namespace fail;
// Check if configuration dependencies are satisfied:
#if !defined(CONFIG_EVENT_BREAKPOINTS) || !defined(CONFIG_SR_RESTORE) || \
!defined(CONFIG_SR_SAVE) || !defined(CONFIG_EVENT_TRAP)
#error This experiment needs: breakpoints, traps, save, and restore. Enable these in the configuration.
#endif
bool ChecksumOOStuBSExperiment::run()
{
// char const *statename = "checksum-oostubs.state"; // FIXME: Variable is unused!
Logger log("Checksum-OOStuBS", false);
BPSingleEvent bp;
log << "startup" << endl;
#if 1
// STEP 0: record memory map with addresses of "interesting" objects
GuestEvent g;
while (true) {
simulator.addEventAndWait(&g);
cout << g.getData() << flush;
}
#elif 0
// STEP 1: run until interesting function starts, and save state
bp.setWatchInstructionPointer(OOSTUBS_FUNC_ENTRY);
simulator.addEventAndWait(&bp);
log << "test function entry reached, saving state" << endl;
log << "EIP = " << hex << bp.getTriggerInstructionPointer() << endl;
log << "error_corrected = " << dec << ((int)simulator.getMemoryManager().getByte(OOSTUBS_ERROR_CORRECTED)) << endl;
simulator.save(statename);
assert(bp.getTriggerInstructionPointer() == OOSTUBS_FUNC_ENTRY);
assert(simulator.getRegisterManager().getInstructionPointer() == OOSTUBS_FUNC_ENTRY);
#elif 1
// STEP 2: record trace for fault-space pruning
log << "restoring state" << endl;
simulator.restore(statename);
log << "EIP = " << hex << simulator.getRegisterManager().getInstructionPointer() << endl;
assert(simulator.getRegisterManager().getInstructionPointer() == OOSTUBS_FUNC_ENTRY);
log << "enabling tracing" << endl;
TracingPlugin tp;
// restrict memory access logging to injection target
MemoryMap mm;
for (unsigned i = 0; i < sizeof(memoryMap)/sizeof(*memoryMap); ++i) {
mm.add(memoryMap[i][0], memoryMap[i][1]);
}
tp.restrictMemoryAddresses(&mm);
// record trace
char const *tracefile = "trace.pb";
ofstream of(tracefile);
tp.setTraceFile(&of);
// this must be done *after* configuring the plugin:
simulator.addFlow(&tp);
bp.setWatchInstructionPointer(ANY_ADDR);
bp.setCounter(OOSTUBS_NUMINSTR);
simulator.addEvent(&bp);
BPSingleEvent func_finish(OOSTUBS_FUNC_FINISH);
simulator.addEvent(&func_finish);
if (simulator.waitAny() == &func_finish) {
log << "experiment reached finish()" << endl;
// FIXME add instruction counter to SimulatorController
simulator.waitAny();
}
log << "experiment finished after " << dec << OOSTUBS_NUMINSTR << " instructions" << endl;
uint32_t results[OOSTUBS_RESULTS_BYTES / sizeof(uint32_t)];
simulator.getMemoryManager().getBytes(OOSTUBS_RESULTS_ADDR, sizeof(results), results);
for (unsigned i = 0; i < sizeof(results) / sizeof(*results); ++i) {
log << "results[" << i << "]: " << dec << results[i] << endl;
}
simulator.removeFlow(&tp);
// serialize trace to file
if (of.fail()) {
log << "failed to write " << tracefile << endl;
simulator.clearEvents(this);
return false;
}
of.close();
log << "trace written to " << tracefile << endl;
#elif 1
// FIXME consider moving experiment repetition into Fail* or even the
// SAL -- whether and how this is possible with the chosen backend is
// backend specific
while (true) {
// STEP 3: The actual experiment.
log << "restoring state" << endl;
simulator.restore(statename);
// get an experiment parameter set
log << "asking job server for experiment parameters" << endl;
ChecksumOOStuBSExperimentData param;
if (!m_jc.getParam(param)) {
log << "Dying." << endl;
// communicate that we were told to die
simulator.terminate(1);
}
/*
// XXX debug
param.msg.set_instr_offset(2576034);
param.msg.set_instr_address(1066640);
param.msg.set_mem_addr(1099428);
param.msg.set_bit_offset(4);
*/
int id = param.getWorkloadID();
int instr_offset = param.msg.instr_offset();
int mem_addr = param.msg.mem_addr();
int bit_offset = param.msg.bit_offset();
log << "job " << id << " instr " << instr_offset << " mem " << mem_addr << "+" << bit_offset << endl;
// XXX debug
stringstream fname;
fname << "job." << ::getpid();
ofstream job(fname.str().c_str());
job << "job " << id << " instr " << instr_offset << " (" << param.msg.instr_address() << ") mem " << mem_addr << "+" << bit_offset << endl;
job.close();
// reaching finish() could happen before OR after FI
BPSingleEvent func_finish(OOSTUBS_FUNC_FINISH);
simulator.addEvent(&func_finish);
bool finish_reached = false;
// no need to wait if offset is 0
if (instr_offset > 0) {
// XXX test this with coolchecksum first (or reassure with sanity checks)
// XXX could be improved with intermediate states (reducing runtime until injection)
bp.setWatchInstructionPointer(ANY_ADDR);
bp.setCounter(instr_offset);
simulator.addEvent(&bp);
// finish() before FI?
if (simulator.waitAny() == &func_finish) {
finish_reached = true;
log << "experiment reached finish() before FI" << endl;
// wait for bp
simulator.waitAny();
}
}
// --- fault injection ---
MemoryManager& mm = simulator.getMemoryManager();
byte_t data = mm.getByte(mem_addr);
byte_t newdata = data ^ (1 << bit_offset);
mm.setByte(mem_addr, newdata);
// note at what IP we did it
int32_t injection_ip = simulator.getRegisterManager().getInstructionPointer();
param.msg.set_injection_ip(injection_ip);
log << "fault injected @ ip " << injection_ip
<< " 0x" << hex << ((int)data) << " -> 0x" << ((int)newdata) << endl;
// sanity check
if (param.msg.has_instr_address() &&
injection_ip != param.msg.instr_address()) {
stringstream ss;
ss << "SANITY CHECK FAILED: " << injection_ip
<< " != " << param.msg.instr_address();
log << ss.str() << endl;
param.msg.set_resulttype(param.msg.UNKNOWN);
param.msg.set_latest_ip(injection_ip);
param.msg.set_details(ss.str());
simulator.clearEvents();
m_jc.sendResult(param);
continue;
}
// --- aftermath ---
// four possible outcomes:
// - guest causes a trap, "crashes"
// - guest reaches a "weird" state, stops with CLI+HLT ("panic")
// - guest runs OOSTUBS_NUMINSTR+OOSTUBS_RECOVERYINSTR instructions but
// never reaches finish()
// - guest reaches finish() within OOSTUBS_NUMINSTR+OOSTUBS_RECOVERYINSTR
// instructions with
// * a wrong result[0-2]
// * a correct result[0-2]
// catch traps as "extraordinary" ending
TrapEvent ev_trap(ANY_TRAP);
simulator.addEvent(&ev_trap);
// OOStuBS' way to terminally halt (CLI+HLT)
BPSingleEvent ev_halt(OOSTUBS_FUNC_CPU_HALT);
simulator.addEvent(&ev_halt);
// remaining instructions until "normal" ending
BPSingleEvent ev_done(ANY_ADDR);
ev_done.setCounter(OOSTUBS_NUMINSTR + OOSTUBS_RECOVERYINSTR - instr_offset);
simulator.addEvent(&ev_done);
/*
// XXX debug
log << "enabling tracing" << endl;
TracingPlugin tp;
tp.setLogIPOnly(true);
tp.setOstream(&cout);
// this must be done *after* configuring the plugin:
simulator.addFlow(&tp);
*/
BaseEvent* ev = simulator.waitAny();
// Do we reach finish() while waiting for ev_trap/ev_done?
if (ev == &func_finish) {
finish_reached = true;
log << "experiment reached finish()" << endl;
// wait for ev_trap/ev_done
ev = simulator.waitAny();
}
// record resultdata, finish_reached and error_corrected regardless of result
uint32_t results[OOSTUBS_RESULTS_BYTES / sizeof(uint32_t)];
simulator.getMemoryManager().getBytes(OOSTUBS_RESULTS_ADDR, sizeof(results), results);
for (unsigned i = 0; i < sizeof(results) / sizeof(*results); ++i) {
log << "results[" << i << "]: " << dec << results[i] << endl;
param.msg.add_resultdata(results[i]);
}
param.msg.set_finish_reached(finish_reached);
int32_t error_corrected = simulator.getMemoryManager().getByte(OOSTUBS_ERROR_CORRECTED);
param.msg.set_error_corrected(error_corrected);
param.msg.set_latest_ip(simulator.getRegisterManager().getInstructionPointer());
if (ev == &ev_done) {
log << dec << "Result FINISHED" << endl;
param.msg.set_resulttype(param.msg.FINISHED);
} else if (ev == &ev_halt) {
log << dec << "Result HALT" << endl;
param.msg.set_resulttype(param.msg.HALT);
} else if (ev == &ev_trap) {
log << dec << "Result TRAP #" << ev_trap.getTriggerNumber() << endl;
param.msg.set_resulttype(param.msg.TRAP);
stringstream ss;
ss << ev_trap.getTriggerNumber();
param.msg.set_details(ss.str());
} else {
log << dec << "Result WTF?" << endl;
param.msg.set_resulttype(param.msg.UNKNOWN);
stringstream ss;
ss << "eventid " << ev->getId() << " EIP " << simulator.getRegisterManager().getInstructionPointer();
param.msg.set_details(ss.str());
}
m_jc.sendResult(param);
}
#endif
// Explicitly terminate, or the simulator will continue to run.
simulator.terminate();
}

14
src/experiments/checksum-oostubs/experiment.hpp Normal file
View File

@ -0,0 +1,14 @@
#ifndef __CHECKSUM_OOSTUBS_EXPERIMENT_HPP__
#define __CHECKSUM_OOSTUBS_EXPERIMENT_HPP__
#include "efw/ExperimentFlow.hpp"
#include "efw/JobClient.hpp"
class ChecksumOOStuBSExperiment : public fail::ExperimentFlow {
fail::JobClient m_jc;
public:
ChecksumOOStuBSExperiment() : m_jc("ios.cs.tu-dortmund.de") {}
bool run();
};
#endif // __CHECKSUM_OOSTUBS_EXPERIMENT_HPP__

51
src/experiments/checksum-oostubs/experimentInfo.hpp Normal file
View File

@ -0,0 +1,51 @@
#ifndef __EXPERIMENT_INFO_HPP__
#define __EXPERIMENT_INFO_HPP__
// FIXME autogenerate this
#if 1 // with ECC
// the task function's entry address:
// nm -C ecc.elf|fgrep main
#define OOSTUBS_FUNC_ENTRY 0x00103f2c
// empty function that is called explicitly when the experiment finished
// nm -C ecc.elf|fgrep "finished()"
#define OOSTUBS_FUNC_FINISH 0x001093f0
// function executing HLT with no chance for further progress (after panic())
// nm -C ecc.elf|fgrep cpu_halt
#define OOSTUBS_FUNC_CPU_HALT 0x00100987
// number of instructions the target executes under non-error conditions from ENTRY to DONE:
// (result of experiment's step #2)
#define OOSTUBS_NUMINSTR 0x4a3401
// number of instructions that are executed additionally for error corrections
// (this is a rough guess ... TODO)
#define OOSTUBS_RECOVERYINSTR 0x2000
// the ECC protected object's address:
// nm -C ecc.elf|fgrep objectUnderTest
#define COOL_ECC_OBJUNDERTEST 0x002127a4 //FIXME
// the ECC protected object's payload size:
// (we know that from the object's definition and usual memory layout)
#define COOL_ECC_OBJUNDERTEST_SIZE 10 //FIXME
// the variable that's increased if ECC corrects an error:
// nm -C ecc.elf|fgrep errors_corrected
#define OOSTUBS_ERROR_CORRECTED 0x0010e3a4
//
// nm -C ecc.elf|fgrep results
#define OOSTUBS_RESULTS_ADDR 0x0010d794
#define OOSTUBS_RESULTS_BYTES 12
#define OOSTUBS_RESULT0 0xab3566a9
#define OOSTUBS_RESULT1 0x44889112
#define OOSTUBS_RESULT2 0x10420844
#else // without ECC
#define COOL_ECC_FUNC_ENTRY 0x00200a90
#define COOL_ECC_CALCDONE 0x00200ab7
#define COOL_ECC_NUMINSTR 97
#define COOL_ECC_OBJUNDERTEST 0x0021263c
#define COOL_ECC_OBJUNDERTEST_SIZE 10
#define COOL_ECC_ERROR_CORRECTED 0x002127b0 // dummy
#endif
#endif // __EXPERIMENT_INFO_HPP__

15
src/experiments/checksum-oostubs/main.cc Normal file
View File

@ -0,0 +1,15 @@
#include <iostream>
#include <cstdlib>
#include "cpn/CampaignManager.hpp"
#include "campaign.hpp"
int main(int argc, char **argv)
{
ChecksumOOStuBSCampaign c;
if (fail::campaignmanager.runCampaign(&c)) {
return 0;
} else {
return 1;
}
}