/***
* Nudge the state towards the observed number of infected
* keeping the proportions of sub-states within both
* infected and uninfected sets roughly the same.
***/
void Population::nudge(int obsInfected) {
const double obsMix = 1.0;
double targetInfected, infectedMultiplier, uninfectedMultiplier;
std::array<double,11> frequencies = getFrequencies();
double pInfected = frequencies[1] + frequencies[2] + frequencies[3];
targetInfected = obsInfected*obsMix/N_AGENTS + pInfected*(1.0-obsMix);
infectedMultiplier = targetInfected/pInfected;
uninfectedMultiplier = (1.0-targetInfected)/(1.0-pInfected);
frequencies[0] *= uninfectedMultiplier;
frequencies[1] *= infectedMultiplier;
frequencies[2] *= infectedMultiplier;
frequencies[3] *= infectedMultiplier;
frequencies[4] *= uninfectedMultiplier;
frequencies[5] *= uninfectedMultiplier;
frequencies[6] *= uninfectedMultiplier;
frequencies[7] *= uninfectedMultiplier;
frequencies[8] *= uninfectedMultiplier;
frequencies[9] *= uninfectedMultiplier;
frequencies[10]*= uninfectedMultiplier;
setFrequencies(frequencies);
}
void
DistributedDVFSManager::receiveKernelMessage(KernelMessage* kMsg) {
UsefulWorkMessage* msg = dynamic_cast<UsefulWorkMessage*>(kMsg);
ASSERT(msg);
std::vector<double> dat;
UsefulWorkMessage::MessageRound round = msg->getRound();
bool idxsChanged = false;
msg->getData(dat);
if(round == UsefulWorkMessage::COLLECT) {
fillUsefulWork(dat);
if(isMaster()) {
for(int i = 0; i < dat.size(); i++)
myUtilFilters[i].update(dat[i]);
if(!isDummy())
idxsChanged = updateFrequencyIdxs();
if(debugPrint())
for(int i = 0; i < dat.size(); i++)
writeCSVRow(i,
myUtilFilters[i].getData(),
myAvailableFreqs[myFrequencyIdxs[i]]);
}
}
else if(round == UsefulWorkMessage::SETFREQ && !isDummy())
setFrequencies(static_cast<int>(dat[mySimulationManagerID]));
// forward message to next node unless we're the master and either
// we just received a set frequency message or the frequencies haven't changed
if(!(isMaster() && (round == UsefulWorkMessage::SETFREQ || !idxsChanged))) {
int dest = (mySimulationManagerID + 1) % myNumSimulationManagers;
UsefulWorkMessage::MessageRound newRound =
isMaster() ? UsefulWorkMessage::SETFREQ : round;
UsefulWorkMessage* newMsg = new UsefulWorkMessage(mySimulationManagerID,
dest,
myNumSimulationManagers,
newRound);
if(isMaster())
for(int i=0; i < myFrequencyIdxs.size(); i++)
dat[i] = static_cast<double>(myFrequencyIdxs[i]);
newMsg->setData(dat);
myCommunicationManager->sendMessage(newMsg, dest);
}
else
myWaitingForMessage = false;
delete kMsg;
}
void
DistributedDVFSManager::configure(SimulationConfiguration &config) {
DVFSManagerImplementationBase::configure(config);
// initialize the frequency index array now that we know how many
// frequencies are available
int maxidx = myAvailableFreqs.size() - 1;
// build the frequency index array based on the number of P states available
initializeFrequencyIdxs(maxidx);
// initialize my frequency to the median frequency
char hostname[32];
gethostname(hostname, 32);
int freqIdx = maxidx / 2;
cout << "DVFSManager on " << hostname << " here. "
<< "initializing all frequencies to "
<< myAvailableFreqs[freqIdx] << endl;
setGovernors("userspace");
setFrequencies(freqIdx);
}
DistributedDVFSManager::~DistributedDVFSManager() {
// if we set the governor back to ondemand, we'll lose our write privileges
// on scaling_setspeed
//setGovernors("ondemand");
setFrequencies(0);
}
