void ThreadedOptFossilCollManager::makeInitialCheckpoint() {
vector<State *> *states = new vector<State*> (
mySimManager->getNumberOfSimulationObjects(), NULL);
checkpointedStates.insert(
pair<int, vector<State*> *> (firstCheckpointTime, states));
unsigned int simMgrID = mySimManager->getSimulationManagerID();
for (int i = 0; i < mySimManager->getNumberOfSimulationObjects(); i++) {
SimulationObject *object = mySimManager->getObjectHandle(
ObjectID(i, simMgrID));
// Save the state of the object at the checkpoint time.
State *newState = object->allocateState();
newState->copyState(object->getState());
(*states)[i] = newState;
lastCheckpointTime[i] = firstCheckpointTime;
stringstream fname;
fname << ckptFilePath << "LP" << simMgrID << "." << firstCheckpointTime
<< "." << i;
ofstream ckptFile(fname.str().c_str(), ofstream::binary);
if (!ckptFile.is_open()) {
cerr << simMgrID << " - Could not open file: " << fname.str()
<< ", aborting simulation." << endl;
abort();
}
//cout << mySimManager->getOutputManagerNew();
mySimManager->getOutputManagerNew()->saveOutputCheckpoint(&ckptFile,
ObjectID(i, simMgrID), lastCheckpointTime[i], 1); // ThreadId hard-coded as 1 as it is the manager
ckptFile.close();
}
}
void LocationObject::migrateLocationEvent( IntVTime currentTime,
LocationState *locationState ) {
/* Randomly decide whether to migrate any person */
if( !diffusionRandGen->genRandNum(SAMPLING_FREQ) ) {
/* Decide a random location */
string selectedLocation = diffusionNetwork->getLocationName();
if( "" != selectedLocation ) {
int travelTime = (int) ( diffusionNetwork->travelTimeToChosenLoc(selectedLocation) );
SimulationObject *receiver = getObjectHandle(selectedLocation);
/* Decide a random person */
Person *person = diffusionNetwork->getPerson( locationState->getPersonMap() );
if(person) {
EpidemicEvent *migrateLocEvent = new EpidemicEvent( currentTime,
currentTime + travelTime,
this,
receiver,
person,
DIFFUSION );
receiver->receiveEvent(migrateLocEvent);
locationState->deletePersonFromLocation(person);
}
}
}
}
void
Process::executeProcess(){
IntVTime sendTime = dynamic_cast<const IntVTime&>(getSimulationTime());
do {
PHOLDEvent* recvEvent = (PHOLDEvent*) getEvent();
if( recvEvent != NULL ){
ProcessState* myState = (ProcessState *) getState();
myState->eventReceived();
SimulationObject* receiver = getDestination(myState);
// Generate the delay between the send and receive times.
int ldelay = msgDelay();
IntVTime recvTime = sendTime + 1 + ldelay;
PHOLDEvent* newRequest = new PHOLDEvent(sendTime, recvTime, this, receiver);
newRequest->numberOfHops = recvEvent->numberOfHops + 1;
newRequest->eventNumber = recvEvent->eventNumber;
computationGrain();
receiver->receiveEvent(newRequest);
myState->eventSent();
}
} while(haveMoreEvents() == true); // end of while loop
}
bool DynamicOutputManager::checkDynamicCancel(const Event* event) {
//This method will just perform the LazyOutputManager::checkLazyCancelEvent.
//Based on the bool result, a hit or miss will be recorded.
//Messages are only suppressed when the current mode is Lazy and there is a hit.
//The curMeasured will be kept track of using the filterdepth.
//The event will not be inserted and events will not be cancelled.
bool suppressMessage = false;
bool lazyCancelHit = false;
int numCancelledEvents = 0;
SimulationObject* sender = getSimulationManager()->getObjectHandle(event->getSender());
int objID = sender->getObjectID()->getSimulationObjectID();
// Only do the check if there are any events to check.
if ((lazyQueues[objID])->size() > 0) {
if (!permanentlyAggressive[objID]) {
setCompareMode(sender, curCancelMode[objID] == LAZY);
lazyCancelHit = LazyOutputManager::checkLazyCancelEvent(event);
numCancelledEvents = (eventsToCancel[objID])->size();
if (curCancelMode[objID] == LAZY) {
suppressMessage = lazyCancelHit;
if (lazyCancelHit && getCompareMode(sender)) {
//Inserting the original event, reclaim this one.
sender->reclaimEvent(event);
} else {
OutputManagerImplementationBase::insert(event);
}
LazyOutputManager::handleCancelEvents(sender);
} else {
eventsToCancel[objID]->clear();
OutputManagerImplementationBase::insert(event);
}
// Record a lazy hit.
if (lazyCancelHit) {
(*(comparisonResults[objID]))[curMeasured[objID] % filterDepth] = 1;
curMeasured[objID] = curMeasured[objID] + 1;
}
// Record a lazy miss.
// Misses may have to be recorded as the size of the cancellation queue eventsToCancel.
for (int i = 0; i < numCancelledEvents ; i++) {
(*(comparisonResults[objID]))[curMeasured[objID] % filterDepth] = 0;
curMeasured[objID] = curMeasured[objID] + 1;;
}
if (curMeasured[objID] >= filterDepth) {
determineCancellationMode(objID);
curMeasured[objID] = 0;
}
} else {
OutputManagerImplementationBase::insert(event);
}
} else {
OutputManagerImplementationBase::insert(event);
}
return suppressMessage;
}
void
CentralizedEventSetSchedulingImplementationBase::runProcesses( const Event *event ){
SimulationObject *scheduledSimulationObject = NULL;
ASSERT(mySimulationManager != NULL);
scheduledSimulationObject = mySimulationManager->getObjectHandle( event->getReceiver() );
ASSERT(scheduledSimulationObject != NULL);
scheduledSimulationObject->executeProcess();
delete lastScheduledEventTime;
lastScheduledEventTime = event->getReceiveTime().clone();
}
bool
DefaultTimeWarpEventSet::insert( const Event *event ){
bool retval = false;
ASSERT( event != 0 );
SimulationObject *object = mySimulationManager->getObjectHandle( event->getReceiver() );
ASSERT( object != 0 );
if( event->getReceiveTime() < object->getSimulationTime() ){
retval = true;
}
getEventContainer( object->getObjectID() ).insert( event );
return retval;
}
void LocationObject::sendCapturedData( IntVTime currentTime,
unsigned int uninfectedNum,
unsigned int latentNum,
unsigned int incubatingNum,
unsigned int infectiousNum,
unsigned int asymptNum,
unsigned int recoveredNum ) {
SimulationObject *receiver = getObjectHandle("writer");
FileEvent *fileEvent = new FileEvent( currentTime, currentTime,
this, receiver,
locationName, countIntraLocDiseaseUpdate,
uninfectedNum, latentNum, incubatingNum,
infectiousNum, asymptNum, recoveredNum);
receiver->receiveEvent(fileEvent);
}
/* dont check target time, if *targetTime==NULL */
void ntlWorld::singleStepSims(double targetTime) {
const bool debugTime = false;
//double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getTimestep();
if(debugTime) errMsg("ntlWorld::singleStepSims","Target time: "<<targetTime);
for(size_t i=0;i<mpSims->size();i++) {
SimulationObject *sim = (*mpSims)[i];
if(!sim->getVisible()) continue;
if(sim->getPanic()) continue;
bool done = false;
while(!done) {
// try to prevent round off errs
if(debugTime) errMsg("ntlWorld::singleStepSims","Test sim "<<i<<" curt:"<< sim->getCurrentTime()<<" target:"<<targetTime<<" delta:"<<(targetTime - sim->getCurrentTime())<<" stept:"<<sim->getTimestep()<<" leps:"<<LBM_TIME_EPSILON ); // timedebug
if( (targetTime - sim->getCurrentTime()) > LBM_TIME_EPSILON) {
if(debugTime) errMsg("ntlWorld::singleStepSims","Stepping sim "<<i<<" t:"<< sim->getCurrentTime()); // timedebug
sim->step();
} else {
done = true;
}
}
}
mSimulationTime = (*mpSims)[mFirstSim]->getCurrentTime();
#ifndef NOGUI
if(mpOpenGLRenderer) mpOpenGLRenderer->notifyOfNextStep(mSimulationTime);
#endif // NOGUI
}
void
MemSourceObject::executeProcess(){
MemSourceState *myState = static_cast<MemSourceState *>(getState());
MemRequest* received = NULL;
IntVTime sendTime = static_cast<const IntVTime&>(getSimulationTime());
//int id = getObjectID()->getSimulationObjectID();
while(true == haveMoreEvents()) {
received = (MemRequest*)getEvent();
if(received != NULL){
myState->filter.update((double)((IntVTime &)getSimulationTime() -
received->getStartTime() ).getTime() );
int requestsCompleted = myState->numMemRequests;
if (requestsCompleted < maxMemRequests ) {
double ldelay = 1.0;
// we want the memRequest to get there at the exact scheduled time
SimulationObject *receiver = getObjectHandle(destObjName);
IntVTime recvTime = sendTime + (int) ldelay;
MemRequest *newMemRequest = new MemRequest(sendTime,
recvTime,
this,
receiver);
newMemRequest->setProcessor(getName());
newMemRequest->setStartTime(sendTime.getTime());
myState->numMemRequests++;
myState->oldDelay = sendTime;
receiver->receiveEvent(newMemRequest);
}
}
}
}
int ntlWorld::addDomain(elbeemSimulationSettings *settings)
{
// create domain obj
SimulationObject *sim = new SimulationObject();
char simname[100];
snprintf(simname,100,"domain%04d",globalDomainCounter);
globalDomainCounter++;
sim->setName(string(simname));
mpGlob->getSims()->push_back( sim );
// important - add to both, only render scene objects are free'd
mpGlob->getRenderScene()->addGeoClass( sim );
mpGlob->getSimScene()->addGeoClass( sim );
sim->setGeoStart(ntlVec3Gfx(settings->geoStart[0],settings->geoStart[1],settings->geoStart[2]));
sim->setGeoEnd(ntlVec3Gfx(
settings->geoStart[0]+settings->geoSize[0],
settings->geoStart[1]+settings->geoSize[1],
settings->geoStart[2]+settings->geoSize[2] ));
// further init in postGeoConstrInit/initializeLbmSimulation of SimulationObject
sim->copyElbeemSettings(settings);
Parametrizer *param = sim->getParametrizer();
param->setSize( settings->resolutionxyz );
param->setDomainSize( settings->realsize );
param->setAniStart( settings->animStart );
param->setNormalizedGStar( settings->gstar );
// init domain channels
vector<ParamFloat> valf;
vector<ParamVec> valv;
vector<double> time;
#define INIT_CHANNEL_FLOAT(channel,size) \
valf.clear(); time.clear(); elbeemSimplifyChannelFloat(channel,&size); \
for(int i=0; i<size; i++) { valf.push_back( channel[2*i+0] ); time.push_back( channel[2*i+1] ); }
#define INIT_CHANNEL_VEC(channel,size) \
valv.clear(); time.clear(); elbeemSimplifyChannelVec3(channel,&size); \
for(int i=0; i<size; i++) { valv.push_back( ParamVec(channel[4*i+0],channel[4*i+1],channel[4*i+2]) ); time.push_back( channel[4*i+3] ); }
param->setViscosity( settings->viscosity );
if((settings->channelViscosity)&&(settings->channelSizeViscosity>0)) {
INIT_CHANNEL_FLOAT(settings->channelViscosity, settings->channelSizeViscosity);
param->initViscosityChannel(valf,time); }
param->setGravity( ParamVec(settings->gravity[0], settings->gravity[1], settings->gravity[2]) );
if((settings->channelGravity)&&(settings->channelSizeGravity>0)) {
INIT_CHANNEL_VEC(settings->channelGravity, settings->channelSizeGravity);
param->initGravityChannel(valv,time); }
param->setAniFrameTimeChannel( settings->aniFrameTime );
if((settings->channelFrameTime)&&(settings->channelSizeFrameTime>0)) {
INIT_CHANNEL_FLOAT(settings->channelFrameTime, settings->channelSizeFrameTime);
param->initAniFrameTimeChannel(valf,time); }
#undef INIT_CHANNEL_FLOAT
#undef INIT_CHANNEL_VEC
// might be set by previous domain
if(mpGlob->getAniFrames() < settings->noOfFrames) mpGlob->setAniFrames( settings->noOfFrames );
// set additionally to SimulationObject->mOutFilename
mpGlob->setOutFilename( settings->outputPath );
return 0;
}
/******************************************************************************
* advance simulations by time t
*****************************************************************************/
int ntlWorld::advanceSims(int framenum)
{
bool done = false;
bool allPanic = true;
// stop/quit, dont display/render
if(getElbeemState()==SIMWORLD_STOP) {
return 1;
}
for(size_t i=0;i<mpSims->size();i++) { (*mpSims)[i]->setFrameNum(framenum); }
double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getFrameTime(framenum);
// time stopped? nothing else to do...
if( (*mpSims)[mFirstSim]->getFrameTime(framenum) <= 0.0 ){
done=true; allPanic=false;
}
int gstate = 0;
myTime_t advsstart = getTime();
// step all the sims, and check for panic
debMsgStd("ntlWorld::advanceSims",DM_MSG, " sims "<<mpSims->size()<<" t"<<targetTime<<" done:"<<done<<" panic:"<<allPanic<<" gstate:"<<gstate, 10); // debug // timedebug
while(!done) {
double nextTargetTime = (*mpSims)[mFirstSim]->getCurrentTime() + (*mpSims)[mFirstSim]->getTimestep();
singleStepSims(nextTargetTime);
// check target times
done = true;
allPanic = false;
if((*mpSims)[mFirstSim]->getTimestep() <1e-9 ) {
// safety check, avoid timesteps that are too small
errMsg("ntlWorld::advanceSims","Invalid time step, causing panic! curr:"<<(*mpSims)[mFirstSim]->getCurrentTime()<<" next:"<<nextTargetTime<<", stept:"<< (*mpSims)[mFirstSim]->getTimestep() );
allPanic = true;
} else {
for(size_t i=0;i<mpSims->size();i++) {
if(!(*mpSims)[i]->getVisible()) continue;
if((*mpSims)[i]->getPanic()) allPanic = true; // do any panic now!?
debMsgStd("ntlWorld::advanceSims",DM_MSG, "Sim "<<i<<", currt:"<<(*mpSims)[i]->getCurrentTime()<<", nt:"<<nextTargetTime<<", panic:"<<(*mpSims)[i]->getPanic()<<", targett:"<<targetTime, 10); // debug // timedebug
}
}
if( (targetTime - (*mpSims)[mFirstSim]->getCurrentTime()) > LBM_TIME_EPSILON) done=false;
if(allPanic) done = true;
}
if(allPanic) {
warnMsg("ntlWorld::advanceSims","All sims panicked... stopping thread" );
setStopRenderVisualization( true );
return 1;
}
myTime_t advsend = getTime();
debMsgStd("ntlWorld::advanceSims",DM_MSG,"Overall steps so far took:"<< getTimeString(advsend-advsstart)<<" for sim time "<<targetTime, 4);
// finish step
for(size_t i=0;i<mpSims->size();i++) {
SimulationObject *sim = (*mpSims)[i];
if(!sim->getVisible()) continue;
if(sim->getPanic()) continue;
sim->prepareVisualization();
}
return 0;
}
/******************************************************************************
* Only dump time dep. objects to file
*****************************************************************************/
int ntlBlenderDumper::renderScene( void )
{
char nrStr[5]; /* nr conversion */
ntlRenderGlobals *glob = mpGlob;
ntlScene *scene = mpGlob->getSimScene();
bool debugOut = false;
bool debugRender = false;
#if ELBEEM_PLUGIN==1
debugOut = false;
#endif // ELBEEM_PLUGIN==1
vector<string> gmName; // gm names
vector<string> gmMat; // materials for gm
int numGMs = 0; // no. of .obj models created
if(debugOut) debMsgStd("ntlBlenderDumper::renderScene",DM_NOTIFY,"Dumping geometry data", 1);
long startTime = getTime();
snprintf(nrStr, 5, "%04d", glob->getAniCount() );
// local scene vars
vector<ntlTriangle> Triangles;
vector<ntlVec3Gfx> Vertices;
vector<ntlVec3Gfx> VertNormals;
// check geo objects
int idCnt = 0; // give IDs to objects
for (vector<ntlGeometryClass*>::iterator iter = scene->getGeoClasses()->begin();
iter != scene->getGeoClasses()->end(); iter++) {
if(!(*iter)->getVisible()) continue;
int tid = (*iter)->getTypeId();
if(tid & GEOCLASSTID_OBJECT) {
// normal geom. objects -> ignore
}
if(tid & GEOCLASSTID_SHADER) {
ntlGeometryShader *geoshad = (ntlGeometryShader*)(*iter); //dynamic_cast<ntlGeometryShader*>(*iter);
string outname = geoshad->getOutFilename();
if(outname.length()<1) outname = mpGlob->getOutFilename();
geoshad->notifyShaderOfDump(DUMP_FULLGEOMETRY, glob->getAniCount(),nrStr,outname);
for (vector<ntlGeometryObject*>::iterator siter = geoshad->getObjectsBegin();
siter != geoshad->getObjectsEnd();
siter++) {
if(debugOut) debMsgStd("ntlBlenderDumper::BuildScene",DM_MSG,"added shader geometry "<<(*siter)->getName(), 8);
(*siter)->notifyOfDump(DUMP_FULLGEOMETRY, glob->getAniCount(),nrStr,outname, this->mSimulationTime);
bool doDump = false;
bool isPreview = false;
// only dump final&preview surface meshes
if( (*siter)->getName().find( "final" ) != string::npos) {
doDump = true;
} else if( (*siter)->getName().find( "preview" ) != string::npos) {
doDump = true;
isPreview = true;
}
if(!doDump) continue;
// dont quit, some objects need notifyOfDump call
if((glob_mpactive) && (glob_mpindex>0)) {
continue; //return 0;
}
// only dump geo shader objects
Triangles.clear();
Vertices.clear();
VertNormals.clear();
(*siter)->initialize( mpGlob );
(*siter)->getTriangles(this->mSimulationTime, &Triangles, &Vertices, &VertNormals, idCnt);
idCnt ++;
// WARNING - this is dirty, but simobjs are the only geoshaders right now
SimulationObject *sim = (SimulationObject *)geoshad;
LbmSolverInterface *lbm = sim->getSolver();
// always dump mesh, even empty ones...
// dump to binary file
std::ostringstream boutfilename("");
//boutfilename << ecrpath.str() << outname <<"_"<< (*siter)->getName() <<"_" << nrStr << ".obj";
boutfilename << outname <<"_"<< (*siter)->getName() <<"_" << nrStr;
if(debugOut) debMsgStd("ntlBlenderDumper::renderScene",DM_MSG,"B-Dumping: "<< (*siter)->getName()
<<", triangles:"<<Triangles.size()<<", vertices:"<<Vertices.size()<<
" to "<<boutfilename.str() , 7);
gzFile gzf;
// output velocities if desired
if((!isPreview) && (lbm->getDumpVelocities())) {
std::ostringstream bvelfilename;
bvelfilename << boutfilename.str();
bvelfilename << ".bvel.gz";
gzf = gzopen(bvelfilename.str().c_str(), "wb9");
if(gzf) {
int numVerts;
if(sizeof(numVerts)!=4) {
errMsg("ntlBlenderDumper::renderScene","Invalid int size");
return 1;
}
numVerts = Vertices.size();
gzwrite(gzf, &numVerts, sizeof(numVerts));
for(size_t i=0; i<Vertices.size(); i++) {
// returns smoothed velocity, scaled by frame time
ntlVec3Gfx v = lbm->getVelocityAt( Vertices[i][0], Vertices[i][1], Vertices[i][2] );
// translation not necessary, test rotation & scaling?
for(int j=0; j<3; j++) {
float vertp = v[j];
//if(i<20) errMsg("ntlBlenderDumper","DUMP_VEL final "<<i<<" = "<<v);
gzwrite(gzf, &vertp, sizeof(vertp));
}
}
gzclose( gzf );
}
}
// compress all bobj's
boutfilename << ".bobj.gz";
gzf = gzopen(boutfilename.str().c_str(), "wb1"); // wb9 is slow for large meshes!
if (!gzf) {
errMsg("ntlBlenderDumper::renderScene","Unable to open output '"<<boutfilename<<"' ");
return 1;
}
// dont transform velocity output, this is handled in blender
// current transform matrix
ntlMatrix4x4<gfxReal> *trafo;
trafo = lbm->getDomainTrafo();
if(trafo) {
// transform into source space
for(size_t i=0; i<Vertices.size(); i++) {
Vertices[i] = (*trafo) * Vertices[i];
}
}
// rotate vertnormals
ntlMatrix4x4<gfxReal> rottrafo;
rottrafo.initId();
if(lbm->getDomainTrafo()) {
// dont modifiy original!
rottrafo = *lbm->getDomainTrafo();
ntlVec3Gfx rTrans,rScale,rRot,rShear;
rottrafo.decompose(rTrans,rScale,rRot,rShear);
rottrafo.initRotationXYZ(rRot[0],rRot[1],rRot[2]);
// only rotate here...
for(size_t i=0; i<Vertices.size(); i++) {
VertNormals[i] = rottrafo * VertNormals[i];
normalize(VertNormals[i]); // remove scaling etc.
}
}
// write to file
int numVerts;
if(sizeof(numVerts)!=4) {
errMsg("ntlBlenderDumper::renderScene","Invalid int size");
return 1;
}
numVerts = Vertices.size();
gzwrite(gzf, &numVerts, sizeof(numVerts));
for(size_t i=0; i<Vertices.size(); i++) {
for(int j=0; j<3; j++) {
float vertp = Vertices[i][j];
gzwrite(gzf, &vertp, sizeof(vertp));
}
}
// should be the same as Vertices.size
if(VertNormals.size() != (size_t)numVerts) {
errMsg("ntlBlenderDumper::renderScene","Normals have to have same size as vertices!");
VertNormals.resize( Vertices.size() );
}
gzwrite(gzf, &numVerts, sizeof(numVerts));
for(size_t i=0; i<VertNormals.size(); i++) {
for(int j=0; j<3; j++) {
float normp = VertNormals[i][j];
gzwrite(gzf, &normp, sizeof(normp));
}
}
int numTris = Triangles.size();
gzwrite(gzf, &numTris, sizeof(numTris));
for(size_t i=0; i<Triangles.size(); i++) {
for(int j=0; j<3; j++) {
int triIndex = Triangles[i].getPoints()[j];
gzwrite(gzf, &triIndex, sizeof(triIndex));
}
}
gzclose( gzf );
debMsgStd("ntlBlenderDumper::renderScene",DM_NOTIFY," Wrote: '"<<boutfilename.str()<<"' ", 2);
numGMs++;
}
}
}
// output ecr config file
if(numGMs>0) {
if(debugOut) debMsgStd("ntlBlenderDumper::renderScene",DM_MSG,"Objects dumped: "<<numGMs, 10);
} else {
if((glob_mpactive) && (glob_mpindex>0)) {
// ok, nothing to do anyway...
} else {
errFatal("ntlBlenderDumper::renderScene","No objects to dump! Aborting...",SIMWORLD_INITERROR);
return 1;
}
}
// debug timing
long stopTime = getTime();
debMsgStd("ntlBlenderDumper::renderScene",DM_MSG,"Scene #"<<nrStr<<" dump time: "<< getTimeString(stopTime-startTime) <<" ", 10);
// still render for preview...
if(debugRender) {
debMsgStd("ntlBlenderDumper::renderScene",DM_NOTIFY,"Performing preliminary render", 1);
ntlWorld::renderScene();
}
else {
// next frame
glob->setAniCount( glob->getAniCount() +1 );
}
return 0;
}
void ThreadedOptFossilCollManager::restoreCheckpoint(unsigned int restoredTime) {
for (int i = 0; i < nextCheckpointTime.size(); i++) {
lastCheckpointTime[i] = restoredTime;
nextCheckpointTime[i] = restoredTime + checkpointPeriod;
}
utils::debug << mySimManager->getSimulationManagerID()
<< " - Restoring to checkpoint: " << restoredTime << endl;
// Restore the states to the objects. The actual state queue will be filled
// after all of the events have been transmitted
unsigned int size;
char delIn;
SimulationObject *object;
unsigned int simMgrID = mySimManager->getSimulationManagerID();
vector<State*> *states = checkpointedStates.find(restoredTime)->second;
vector<Event*> restoredEvents;
for (int i = 0; i < mySimManager->getNumberOfSimulationObjects(); i++) {
object = mySimManager->getObjectHandle(ObjectID(i, simMgrID));
object->setSimulationTime(mySimManager->getZero());
object->getState()->copyState((*states)[i]);
stringstream filename;
filename << ckptFilePath << "LP"
<< mySimManager->getSimulationManagerID() << "."
<< restoredTime << "." << i;
ifstream ckFile;
ckFile.open(filename.str().c_str());
if (!ckFile.is_open()) {
cerr << mySimManager->getSimulationManagerID()
<< " - Could not open file: " << filename.str()
<< ", aborting simulation." << endl;
abort();
}
// Read in the events.
while (ckFile.peek() != EOF) {
ckFile.read((char*) (&size), sizeof(size));
ckFile.read(&delIn, sizeof(delIn));
if (delIn != delimiter) {
cerr << mySimManager->getSimulationManagerID()
<< "ALIGNMENT ERROR in Event"
<< "restoreCheckpoint. Got: " << delIn << endl;
abort();
}
char *buf = new char[size];
ckFile.read(buf, size);
SerializedInstance *serEvent = new SerializedInstance(buf, size);
Event *restoredEvent =
dynamic_cast<Event*> (serEvent->deserialize());
delete[] buf;
delete serEvent;
restoredEvents.push_back(restoredEvent);
utils::debug << "restoring to objID "
<< restoredEvent->getSender().getSimulationObjectID()
<< endl;
}
ckFile.close();
}
std::sort(restoredEvents.begin(), restoredEvents.end(),
receiveTimeLessThanEventIdLessThan());
// Restore the output queue and transmit the events to restore the event set.
for (int i = 0; i < restoredEvents.size(); i++) {
mySimManager->handleEvent(restoredEvents[i]);
}
lastRestoreTime = restoredTime;
// Set recovering to false
mySimManager->setRecoveringFromCheckpoint(false);
//myCommManager->setRecoveringFromCheckpoint(false);
utils::debug << mySimManager->getSimulationManagerID()
<< " - Done with restore process, " << restoredTime << endl;
}
void ThreadedOptFossilCollManager::checkpoint(const VTime &checkTime,
const ObjectID &objId, const unsigned int &threadId) {
int time = checkTime.getApproximateIntTime();
int id = objId.getSimulationObjectID();
// If the time is less than the last checkpoint time, then save at the last
// checkpoint time again.
updateCheckpointTime(id, time);
while (time >= nextCheckpointTime[id]) {
utils::debug << mySimManager->getSimulationManagerID()
<< " - Checkpointing object " << id << " at " << time << endl;
int highestNextCheckpointTime = nextCheckpointTime[0];
for (int iter = 1; iter < mySimManager->getNumberOfSimulationObjects(); iter++) {
if (nextCheckpointTime[iter] > highestNextCheckpointTime)
highestNextCheckpointTime = nextCheckpointTime[iter];
}
vector<State *> *states;
if (nextCheckpointTime[id] == highestNextCheckpointTime) {
// No states have been check pointed for this time yet.
// Thus we create a state vector for all the objects
utils::debug << "Creating new states to be saved at time "
<< nextCheckpointTime[id] << endl;
states = new vector<State*> (
mySimManager->getNumberOfSimulationObjects(), NULL);
checkpointedStates.insert(
pair<int, vector<State*> *> (nextCheckpointTime[id], states));
} else {
// States have been saved for other objects but not this object at this time
// or a roll back in this object is causing this to happen.
utils::debug
<< "Adding the current state of the object to checkpointedStates "
<< nextCheckpointTime[id] << endl;
map<int, vector<State*>*>::iterator it = checkpointedStates.find(
nextCheckpointTime[id]);
states = it->second;
}
SimulationObject *object = mySimManager->getObjectHandle(objId);
// Save the state of the object at the checkpoint time.
State *newState = object->allocateState();
newState->copyState(object->getState());
(*states)[id] = newState;
lastCheckpointTime[id] = nextCheckpointTime[id];
nextCheckpointTime[id] += checkpointPeriod;
stringstream filename;
filename << ckptFilePath << "LP"
<< mySimManager->getSimulationManagerID() << "."
<< lastCheckpointTime[id] << "." << id;
ofstream ckFile(filename.str().c_str(), ofstream::binary);
if (!ckFile.is_open()) {
cerr << mySimManager->getSimulationManagerID()
<< " - Could not open file: " << filename.str()
<< ", aborting simulation." << endl;
abort();
}
mySimManager->getOutputManagerNew()->saveOutputCheckpoint(&ckFile,
objId, lastCheckpointTime[id], threadId);
ckFile.close();
}
}
/******************************************************************************
* advance simulations by time t
*****************************************************************************/
int ntlWorld::advanceSims(int framenum)
{
bool done = false;
bool allPanic = true;
// stop/quit (abort), dont display/render
if(!isSimworldOk()) {
return 1;
}
for(size_t i=0;i<mpSims->size();i++) { (*mpSims)[i]->setFrameNum(framenum); }
// time stopped? nothing else to do...
if( (*mpSims)[mFirstSim]->getFrameTime(framenum) <= 0.0 ){
done=true; allPanic=false;
/* DG: Need to check for user cancel here (fix for [#30298]) */
(*mpSims)[mFirstSim]->checkCallerStatus(FLUIDSIM_CBSTATUS_STEP, 0);
}
// Prevent bug [#29186] Object contribute to fluid sim animation start earlier than keyframe
// Was: double targetTime = mSimulationTime + (*mpSims)[mFirstSim]->getFrameTime(framenum); - DG
double totalTime = 0.0, targetTime = 0.0;
for(size_t i = 0; i < mSimFrameCnt; i++)
{
/* We need an intermediate array "mSimFrameValue" because
otherwise if we don't start with starttime = 0,
the sim gets out of sync - DG */
totalTime += (*mpSims)[mFirstSim]->getFrameTime(mSimFrameValue[i]);
}
targetTime = totalTime + (*mpSims)[mFirstSim]->getFrameTime(framenum);
int gstate = 0;
myTime_t advsstart = getTime();
// step all the sims, and check for panic
debMsgStd("ntlWorld::advanceSims",DM_MSG, " sims "<<mpSims->size()<<" t"<<targetTime<<" done:"<<done<<" panic:"<<allPanic<<" gstate:"<<gstate, 10); // debug // timedebug
while(!done) {
double nextTargetTime = (*mpSims)[mFirstSim]->getCurrentTime() + (*mpSims)[mFirstSim]->getTimestep();
singleStepSims(nextTargetTime);
// check target times
done = true;
allPanic = false;
if((*mpSims)[mFirstSim]->getTimestep() <1e-9 ) {
// safety check, avoid timesteps that are too small
errMsg("ntlWorld::advanceSims","Invalid time step, causing panic! curr:"<<(*mpSims)[mFirstSim]->getCurrentTime()<<" next:"<<nextTargetTime<<", stept:"<< (*mpSims)[mFirstSim]->getTimestep() );
allPanic = true;
} else {
for(size_t i=0;i<mpSims->size();i++) {
if(!(*mpSims)[i]->getVisible()) continue;
if((*mpSims)[i]->getPanic()) allPanic = true; // do any panic now!?
debMsgStd("ntlWorld::advanceSims",DM_MSG, "Sim "<<i<<", currt:"<<(*mpSims)[i]->getCurrentTime()<<", nt:"<<nextTargetTime<<", panic:"<<(*mpSims)[i]->getPanic()<<", targett:"<<targetTime, 10); // debug // timedebug
}
}
if( (targetTime - (*mpSims)[mFirstSim]->getCurrentTime()) > LBM_TIME_EPSILON) done=false;
if(allPanic) done = true;
}
if(allPanic) {
warnMsg("ntlWorld::advanceSims","All sims panicked... stopping thread" );
setStopRenderVisualization( true );
return 1;
}
myTime_t advsend = getTime();
debMsgStd("ntlWorld::advanceSims",DM_MSG,"Overall steps so far took:"<< getTimeString(advsend-advsstart)<<" for sim time "<<targetTime, 4);
// finish step
for(size_t i=0;i<mpSims->size();i++) {
SimulationObject *sim = (*mpSims)[i];
if(!sim->getVisible()) continue;
if(sim->getPanic()) continue;
sim->prepareVisualization();
}
mSimFrameValue.push_back(framenum);
mSimFrameCnt++;
return 0;
}
void RAIDDisk::executeProcess() {
RAIDRequest *recvEvent;
RAIDDiskState *myState;
RAIDRequest *newEvent;
RAIDRequest *tmpEvent;
IntVTime recvTime(0);
int seekDist;
double seekTime, a, b, c;
int nextCylinder;
int timeDelay = 1;
int objectId;
IntVTime sendTime = dynamic_cast<const IntVTime&> (getSimulationTime());
myState = (RAIDDiskState *) getState();
while (true == haveMoreEvents()) {
recvEvent = (RAIDRequest*) getEvent();
if (recvEvent != NULL) {
SimulationObject *recvr = getObjectHandle(
recvEvent->getSourceObject());
string receiverName = recvr->getName();
objectId=recvr->getObjectID()->getSimulationObjectID();
tmpEvent = new RAIDRequest(sendTime, sendTime + 1, this, recvr);
*tmpEvent = *recvEvent;
nextCylinder = (tmpEvent->getStartStripe() / (sectorsPerTrack
* tracksPerCyl)) % numCylinders;
tmpEvent->setStartCylinder(nextCylinder);
tmpEvent->setStartSector(
tmpEvent->getStartStripe() % sectorsPerTrack);
seekDist = nextCylinder - myState->getCurrentCylinder();
myState = (RAIDDiskState*) getState();
if (seekDist < 0) {
seekDist = abs(seekDist);
}
if (seekDist != 0) {
a = (-10 * minSeekTime + 15 * avgSeekTime - 5 * maxSeekTime)
/ (3 * sqrt(numCylinders));
b = (7 * minSeekTime - 15 * avgSeekTime + 8 * maxSeekTime) / (3
* numCylinders);
c = minSeekTime;
if (a > 0 && b > 0) {
seekTime = a * sqrt(seekDist - 1) + b * (seekDist - 1) + c;
} else {
cerr << "Disk Model parameters are not correct for model"
<< endl;
seekTime = 0;
}
} else {
seekTime = 0;
}
recvTime = max(sendTime.getApproximateIntTime(), lastEventTime[receiverName])
+ int(seekTime + 0.5 * revolutionTime);
// recvTime = lastEventTime + int(seekTime + 0.5 * revolutionTime);
newEvent = new RAIDRequest(sendTime, recvTime, this, recvr);
//delete lastEventTime;
lastEventTime[receiverName] = recvTime.getApproximateIntTime();
//cout << "LastEvent Time for the Disk = " << lastEventTime << endl;
#if 0
recvTime = VTime(getSimulationTime() +
int(seekTime + 0.5*revolutionTime) + timeDelay++);
newEvent = new RAIDRequest(sendTime, recvTime, this, recvr);
#endif
*newEvent = *tmpEvent;
delete tmpEvent;
myState->setCurrentCylinder(nextCylinder);
// Send event back to source.
recvr->receiveEvent(newEvent);
} // End of if (event != null)
} // End of while "have more events" loop
}
