RAMpage experiment: campaign

git-svn-id: https://www4.informatik.uni-erlangen.de/i4svn/danceos/trunk/devel/fail@1649 8c4709b5-6ec9-48aa-a5cd-a96041d1645a

src/experiments/rampage/CMakeLists.txt

@@ -9,6 +9,7 @@ set(MY_PROTOS
 )
 
 set(MY_CAMPAIGN_SRCS
+	experimentInfo.hpp
 	experiment.hpp
 	experiment.cc
 	campaign.hpp

src/experiments/rampage/campaign.cc

@@ -1,8 +1,9 @@
 #include <iostream>
+#include <fstream>
 
-#include "campaign.hpp"
 #include "cpn/CampaignManager.hpp"
-#include "util/Logger.hpp"
+#include "campaign.hpp"
+#include "experimentInfo.hpp"
 
 using namespace std;
 using namespace fail;
@@ -11,6 +12,74 @@ char const * const results_filename = "rampage.csv";
 
 bool RAMpageCampaign::run()
 {
-	// TODO
+	// TODO read already existing results
+
+	// non-destructive: due to the CSV header we can always manually recover
+	// from an accident (append mode)
+	ofstream results(results_filename, ios::out | ios::app);
+	if (!results.is_open()) {
+		m_log << "failed to open " << results_filename << endl;
+		return false;
+	}
+	results << "addr\tbit1\tbit2\terrortype\tlocal_timeout\tglobal_timeout\tmem_written\tresulttype\terror_detected_pfn\texperiment_time\tdetails" << endl;
+
+	// count address bits needed for memory size
+	unsigned address_bits = 0;
+	for (uint64_t i = 1; i < MEM_SIZE; i <<= 1) {
+		++address_bits;
+	}
+	m_log << dec << MEM_SIZE << "b mem needs "
+	      << address_bits << " address bits" << endl;
+
+	// systematically march through the fault space
+	for (uint64_t n = 0; n < 1024; ++n) {
+		uint64_t addr = reverse_bits(n) >> (64 - address_bits);
+		if (addr >= MEM_SIZE) {
+			continue;
+		}
+
+		RAMpageExperimentData *d = new RAMpageExperimentData;
+		d->msg.set_mem_addr(addr);
+		d->msg.set_mem_bit(4);
+		d->msg.set_errortype(d->msg.ERROR_STUCK_AT_1);
+		d->msg.set_local_timeout(1000*60*10); // 10m
+		d->msg.set_global_timeout(1000*60*50); // 50m
+		campaignmanager.addParam(d);
+	}
+	campaignmanager.noMoreParameters();
+
+	// collect results
+	RAMpageExperimentData *res;
+	while ((res = static_cast<RAMpageExperimentData *>(campaignmanager.getDone()))) {
+		results
+			<< res->msg.mem_addr() << "\t"
+			<< res->msg.mem_bit() << "\t"
+			<< res->msg.mem_coupled_bit() << "\t"
+			<< res->msg.errortype() << "\t"
+			<< res->msg.local_timeout() << "\t"
+			<< res->msg.global_timeout() << "\t"
+			<< res->msg.mem_written() << "\t"
+			<< res->msg.resulttype() << "\t"
+			<< res->msg.error_detected_pfn() << "\t"
+			<< res->msg.experiment_time() << "\t"
+			<< res->msg.details() << endl;
+	}
+	results.close();
 	return true;
 }
+
+uint64_t RAMpageCampaign::reverse_bits(uint64_t v)
+{
+	// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseObvious
+	uint64_t r = v; // r will be reversed bits of v; first get LSB of v
+	int s = sizeof(v) * CHAR_BIT - 1; // extra shift needed at end
+
+	for (v >>= 1; v; v >>= 1)
+	{   
+		r <<= 1;
+		r |= v & 1;
+		s--;
+	}
+	r <<= s; // shift when v's highest bits are zero
+	return r;
+}

src/experiments/rampage/campaign.hpp

@@ -3,6 +3,7 @@
 
 #include "cpn/Campaign.hpp"
 #include "comm/ExperimentData.hpp"
+#include "util/Logger.hpp"
 #include "rampage.pb.h"
 
 class RAMpageExperimentData : public fail::ExperimentData {
@@ -12,7 +13,11 @@ public:
 };
 
 class RAMpageCampaign : public fail::Campaign {
+	fail::Logger m_log;
+
+	static uint64_t reverse_bits(uint64_t v);
 public:
+	RAMpageCampaign() : m_log("RAMpage Campaign") {}
 	virtual bool run();
 };
 

src/experiments/rampage/experiment.cc

@@ -14,7 +14,7 @@
 #include "sal/Memory.hpp"
 #include "sal/Listener.hpp"
 
-#define LOCAL 1
+#define LOCAL 0
 
 #define STR_STATS    "calculating stats"
 #define STR_START    "starting test pass"
@@ -45,14 +45,16 @@ bool RAMpageExperiment::run()
 	m_param = new RAMpageExperimentData;
 #if LOCAL
 	//m_param->msg.set_mem_addr(1024*604+123);
-	m_param->msg.set_mem_addr(1024*1024*63+123);
+	//m_param->msg.set_mem_addr(1024*1024*63+123);
+	m_param->msg.set_mem_addr(73728);
 	m_param->msg.set_mem_bit(7);
-	m_param->msg.set_errortype(m_param->msg.ERROR_STUCK_AT_0);
+	//m_param->msg.set_errortype(m_param->msg.ERROR_STUCK_AT_0);
+	m_param->msg.set_errortype(m_param->msg.ERROR_COUPLING);
 	m_param->msg.set_local_timeout(1000*60*10); // 10m
 	m_param->msg.set_global_timeout(1000*60*50); // 50m
 #else
-	if (!m_jc.getm_param(m_param)) {
+	if (!m_jc.getParam(*m_param)) {
-		log << "Dying." << endl;
+		m_log << "Dying." << endl;
 		// communicate that we were told to die
 		simulator.terminate(1);
 	}
@@ -149,7 +151,6 @@ bool RAMpageExperiment::handleIO(char c)
 		if (m_last_line_was_startingtestpass) {
 			// result: NO_PFNS_TESTED
 			m_log << "no PFNs were tested this time" << std::endl;
-			simulator.terminate();
 			terminateExperiment(m_param->msg.NO_PFNS_TESTED);
 		}
 		m_log << STR_STATS << std::endl;
@@ -188,7 +189,7 @@ void RAMpageExperiment::terminateExperiment(int resulttype)
 	m_param->msg.set_resulttype((RAMpageProtoMsg::ResultType) resulttype);
 	// TODO measure time
 #if !LOCAL
-	m_jc.sendResult(param);
+	m_jc.sendResult(*m_param);
 #endif
 	simulator.terminate();
 }

src/experiments/rampage/experimentInfo.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+#define MEM_SIZE (1024*1024*1024) // the QEMU SAL doesn't supply that information yet