void CostAdaptiveStateManager::saveState(const VTime& currentTime, SimulationObject *object) {
ObjectID *currentObjectID = object->getObjectID();
unsigned int simObjectID = currentObjectID->getSimulationObjectID();
// The period is only recalculated after the specified number of events.
if (forwardExecutionLength[simObjectID] < eventsBetweenRecalculation[simObjectID]) {
forwardExecutionLength[simObjectID]++;
}
else{
calculatePeriod( object );
}
AdaptiveStateManagerBase::saveState(currentTime, object);
}
void ThreadedCostAdaptiveStateManager::saveState(const VTime& currentTime,
SimulationObject *object, int threadID) {
ObjectID *currentObjectID = object->getObjectID();
unsigned int simObjectID = currentObjectID->getSimulationObjectID();
// The period is only recalculated after the specified number of events.
if (forwardExecutionLength[simObjectID]
< eventsBetweenRecalculation[simObjectID]) {
forwardExecutionLength[simObjectID]++;
} else {
calculatePeriod(object);
}
if (periodCounter[simObjectID] <= 1) {
// we need to first allocate a state. Copy the current state into
// this newly created state. Then allocate a state object and
// fill in the current time and a pointer to the newly copied
// current state.
startStateTiming(simObjectID);
State *newState = object->allocateState();
newState->copyState(object->getState());
SetObject<State> stateObject(currentTime, newState);
// look up the state queue of the simulation object and insert the
// newly allocated state object
ThreadedStateManagerImplementationBase::getStateQueueLock(threadID,
simObjectID);
myStateQueue[simObjectID].insert(stateObject);
/*cout << "Saving at the Time Stamp :::::"
<< currentTime.getApproximateIntTime() << endl;*/
ThreadedStateManagerImplementationBase::releaseStateQueueLock(threadID,
simObjectID);
// reset period counter to state period
periodCounter[simObjectID] = objectStatePeriod[simObjectID];
stopStateTiming(simObjectID);
} else {
// decrement period counter
periodCounter[simObjectID] = periodCounter[simObjectID] - 1;
}
}
void ThreadedCostAdaptiveStateManager::updateStateWhileCoastForward(
const VTime& currentTime, unsigned int eventNumber,
SimulationObject *object, const ObjectID senderId, int threadID) {
// store this object's id temporarily
OBJECT_ID *currentObjectID = object->getObjectID();
unsigned int simObjectID = currentObjectID->getSimulationObjectID();
if (mySimulationManager->isRollbackJustCompleted(simObjectID)) {
/*cout << "Last Rollback Time ::{{{{{{{{{{{{{{{{{}}}}}}}} "
<< *(lastRollbackTime[simObjectID]) << endl;*/
multiset<SetObject<State> >::iterator iter_end =
myStateQueue[simObjectID].end();
/*cout << "Current Num = " << eventNumber << "::::: Old Number = "
<< rollbackEventNumber[simObjectID] << endl;*/
if (*(lastRollbackTime[simObjectID]) == currentTime && eventNumber
<= rollbackEventNumber[simObjectID]) {
/*cout << " Need to update the Event Number in the state ::::"
<< eventNumber << endl;*/
ThreadedStateManagerImplementationBase::getStateQueueLock(threadID,
simObjectID);
State *newState = object->allocateState();
newState->copyState(object->getState());
SetObject<State> stateObject(currentTime, newState, eventNumber,
senderId.getSimulationObjectID(),
senderId.getSimulationObjectID());
//object->deallocateState((*iter_end).getElement());
//myStateQueue[simObjectID].erase(iter_end);
// look up the state queue of the simulation object and insert the
// newly allocated state object
myStateQueue[simObjectID].insert(stateObject);
ThreadedStateManagerImplementationBase::releaseStateQueueLock(
threadID, simObjectID);
}
mySimulationManager->resetRollbackCompletedStatus(simObjectID);
}
}
void ThreadedCostAdaptiveStateManager::saveState(const VTime& currentTime,
unsigned int eventNumber, SimulationObject *object,
const ObjectID senderId, int threadID) {
ObjectID *currentObjectID = object->getObjectID();
unsigned int simObjectID = currentObjectID->getSimulationObjectID();
// The period is only recalculated after the specified number of events.
if (forwardExecutionLength[simObjectID]
< eventsBetweenRecalculation[simObjectID]) {
forwardExecutionLength[simObjectID]++;
} else {
calculatePeriod(object);
}
if (mySimulationManager->isRollbackJustCompleted(simObjectID)) {
// cout << "Last Rollback Time ::{{{{{{{{{{{{{{{{{}}}}}}}} "
// << *(lastRollbackTime[simObjectID]) << endl;
multiset<SetObject<State> >::iterator iter_end =
myStateQueue[simObjectID].end();
/*cout << "Current Num = " << eventNumber << "::::: Old Number = "
<< rollbackEventNumber[simObjectID] << endl;*/
if (*(lastRollbackTime[simObjectID]) == currentTime && eventNumber
<= rollbackEventNumber[simObjectID]) {
// cout << " Need to update the Event Number in the state ::::"
// << eventNumber << endl;
ThreadedStateManagerImplementationBase::getStateQueueLock(threadID,
simObjectID);
State *newState = object->allocateState();
newState->copyState(object->getState());
SetObject<State> stateObject(currentTime, newState, eventNumber,
senderId.getSimulationObjectID(),
senderId.getSimulationObjectID());
//object->deallocateState((*iter_end).getElement());
//myStateQueue[simObjectID].erase(iter_end);
// look up the state queue of the simulation object and insert the
// newly allocated state object
myStateQueue[simObjectID].insert(stateObject);
// cout << "Saving at the Time Stamp :::::"
// << currentTime.getApproximateIntTime() << endl;
// cout << "Imm. After savig the EventId ::::;"
// << stateObject.getEventNumber() << endl;
// *iter_end = stateObject;
ThreadedStateManagerImplementationBase::releaseStateQueueLock(
threadID, simObjectID);
}
mySimulationManager->resetRollbackCompletedStatus(simObjectID);
return;
}
if (periodCounter[simObjectID] <= 0) {
// we need to first allocate a state. Copy the current state into
// this newly created state. Then allocate a state object and
// fill in the current time and a pointer to the newly copied
// current state.
State *newState = object->allocateState();
newState->copyState(object->getState());
SetObject<State> stateObject(currentTime, newState, eventNumber,
senderId.getSimulationObjectID(),
senderId.getSimulationObjectID());
// look up the state queue of the simulation object and insert the
// newly allocated state object
ThreadedStateManagerImplementationBase::getStateQueueLock(threadID,
simObjectID);
myStateQueue[simObjectID].insert(stateObject);
// cout << "Saving at the Time Stamp :::::"
// << currentTime.getApproximateIntTime()
// << " With Event Number :::: " << eventNumber
// << " With senderObjectId :::: "
// << senderId.getSimulationObjectID() << endl;
multiset<SetObject<State> >::iterator iter_end =
myStateQueue[simObjectID].end();
iter_end--;
/*cout << "Imm. After saving the EventId ::::::: "
<< (*iter_end).getEventNumber() << endl;
cout << "Imm. After saving the SenderId ::::::: "
<< (*iter_end).getsenderObjectId() << endl;*/
ThreadedStateManagerImplementationBase::releaseStateQueueLock(threadID,
simObjectID);
// reset period counter to state period
periodCounter[simObjectID] = objectStatePeriod[simObjectID];
} else {
// decrement period counter
periodCounter[simObjectID] = periodCounter[simObjectID] - 1;
}
}
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();
}
}
