void
RAIDFork::initialize() {
outputHandles.resize(outputNames.size(),NULL);
for(int i = 0; i < outputHandles.size(); i++){
outputHandles[i] = getObjectHandle(outputNames[i]);
}
} // End of initialize()
void RAIDProcess::newMsg() {
RAIDProcessState *myState = (RAIDProcessState*) getState();
int ldelay = msgDelay();
IntVTime sendTime = dynamic_cast<const IntVTime&> (getSimulationTime());
RAIDRequest* newRequest = new RAIDRequest(sendTime, sendTime + ldelay + 1,
this, outputHandle);
newRequest->setSourceObject(getName());
newRequest->setSinkObject("");
newRequest->setStartCylinder(-1);
DiscreteUniform stripe(0, totalStripeSize, myState->getGen());
DiscreteUniform read(0, 1, myState->getGen());
DiscreteUniform size(1, maxStripeSize, myState->getGen());
newRequest->setStartStripe((int) stripe());
newRequest->setStartSector(-1);
newRequest->setSizeRead((int) size());
newRequest->setLogicalSector(-1);
if (newRequest->getSizeRead() == 0) {
cerr << "\n\n\n\nHold IT! sizeRead = 0\n\n\n\n\n" << "\n";
}
// If we try and read off the end of the array then move our starting
// location, so that we can still read the same amount of data.
if ((newRequest->getStartStripe() + newRequest->getSizeRead())
>= totalStripeSize) {
newRequest->setStartStripe(maxStripeSize - newRequest->getSizeRead());
}
newRequest->setBeginningOfStrype(newRequest->getStartStripe());
newRequest->setTokenNumber(myState->getNumRequests() + 1);
myState->setBeginningOfStrype(newRequest->getBeginningOfStrype());
myState->set_size(newRequest->getSizeRead());
newRequest->setSizeParity(0);
newRequest->setParityMsg(false);
if (read() == 0) {
newRequest->setRead(false);
// cout
// << "Write Started of size---------------------------------------------------------------------------------- "
// << myState->get_size() << endl;
myState->setRead(false);
} else {
newRequest->setRead(true);
myState->setRead(true);
// cout
// << "Read Started of size---------------------------------------------------------------------------------- "
// << myState->get_size() << endl;
}
myState->setDiskOperationPending(true);
myState->setBeginningOfStrype(newRequest->getStartStripe());
myState->setStrypeSize(newRequest->getSizeRead());
myState->setNumRequests(myState->getNumRequests() + 1);
getObjectHandle(outputName)->receiveEvent(newRequest);
} // End of newMsg()
void RAIDProcess::initialize() {
RAIDProcessState *myState = (RAIDProcessState*) getState();
int processNumber = getObjectID()->getSimulationObjectID();
IntVTime sendTime = dynamic_cast<const IntVTime&> (getSimulationTime());
delete (myState->getGen());
MLCG *gen = new MLCG(seed, seed + 1);
myState->setGen(gen);
outputHandle = getObjectHandle(outputName);
newConfiguration();
RAIDRequest* newRequest = new RAIDRequest(sendTime, sendTime + 1, this,
this);
newRequest->setSourceObject(getName());
newRequest->setSinkObject("");
newRequest->setStartCylinder(-1);
newRequest->setStartStripe(-1);
newRequest->setStartSector(-1);
newRequest->setSizeRead(1);
newRequest->setLogicalSector(-1);
newRequest->setRead(true);
newRequest->setParityMsg(false);
newRequest->setBeginningOfStrype(-1);
myState->setBeginningOfStrype(newRequest->getBeginningOfStrype());
myState->setStopProcessing(false);
this->receiveEvent(newRequest);
}
//------------------------------------------------------------------------------
// entityStateManager() -- (Output support)
// -- Update the entity object for this NIB(Player)
//------------------------------------------------------------------------------
bool Nib::entityStateManager(const double curExecTime)
{
bool ok = true;
if (getPlayer()->isMode(simulation::Player::ACTIVE) && isPlayerStateUpdateRequired(curExecTime)) {
// Need to update this entity object ...
NetIO* netIO = static_cast<NetIO*>(getNetIO());
RTI::RTIambassador* rtiAmb = netIO->getRTIambassador();
// ---
// First, make sure this entity has been registered
// ---
if (!isRegistered()) {
try {
RTI::ObjectClassHandle theClassHandle = netIO->getObjectClassHandle( getClassIndex() );
makeObjectName();
setObjectHandle( rtiAmb->registerObjectInstance( theClassHandle, getObjectName() ) );
netIO->addNibToObjectTables(this, simulation::NetIO::OUTPUT_NIB);
std::cout << "rprfom::Nib::updateEntity(): Register entity: " << getObjectName() << " handle = " << getObjectHandle() << std::endl;
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
}
// ---
// Next, update the entity's attribute values ...
// ---
if ( ok && isRegistered()) {
try {
// Create the attribute-value pair set
RTI::AttributeHandleValuePairSet* attrs = nullptr;
attrs = RTI::AttributeSetFactory::create( NetIO::NUM_OBJECT_ATTRIBUTES );
// Load the set with updated attribute values
updateBasicEntity(attrs,curExecTime);
updatePhysicalEntity(attrs,curExecTime);
updatePlatform(attrs,curExecTime);
// Send attributes to the RTI
//std::cout << "RprFom::Nib::updateEntity(): Update entity: " << getObjectName() << " handle = " << getObjectHandle() << std::endl;
ok = netIO->updateAttributeValues(getObjectHandle(), attrs);
delete attrs;
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
}
} // end -- if active player needs an update
return ok;
}
void RobotVREP::addJoint( Joint * joint)
{
int * handler = new int(getObjectHandle(joint->getName(), simx_opmode_oneshot_wait));
VrepHandlerVector.push_back( handler );
jointVector.push_back( joint );
jointIdToVrepHandler_map.insert( std::pair<int,int> ( joint->getUniqueObjectId() , VrepHandlerVector.size() -1 ) );
getJointForce(joint, simx_opmode_streaming);
getJointPosition(joint, simx_opmode_streaming);
}
void RobotVREP::addVisionSensor( VisionSensor * visionSensor )
{
int * handler = new int(getObjectHandle(visionSensor->getName(), simx_opmode_oneshot_wait));
VrepHandlerVector.push_back( handler );
visionSensorVector.push_back( visionSensor );
visionSensorIdToVrepHandler_map.insert( std::pair<int,int> ( visionSensor->getUniqueObjectId() , VrepHandlerVector.size() -1 ) );
getVisionSensorResolution(visionSensor, simx_opmode_streaming);
addObject(visionSensor);
}
void RobotVREP::addObject( Object * object)
{
int * handler = new int(getObjectHandle(object->getName(), simx_opmode_oneshot_wait));
VrepHandlerVector.push_back( handler );
objectVector.push_back( object );
objectIdToVrepHandler_map.insert( std::pair<int,int> ( object->getUniqueObjectId() , VrepHandlerVector.size() -1 ) );
getObjectPosition(object, -1, simx_opmode_streaming);
getObjectOrientation(object, -1, simx_opmode_streaming);
getObjectVelocity(object, simx_opmode_streaming);
}
void ScilabView::createObject(char const* pstId)
{
//std::cerr << "[ScilabView] ++ createObject UID=" << pstId << std::endl;
int iType = -1;
int *piType = &iType;
getGraphicObjectProperty(pstId, __GO_TYPE__, jni_int, (void **)&piType);
if (iType != -1 && iType == __GO_FIGURE__)
{
m_figureList[pstId] = -1;
setCurrentFigure(pstId);
}
// Register object handle.
getObjectHandle(pstId);
}
void
RAIDFork::executeProcess() {
RAIDRequest *recvEvent;
RAIDForkState *myState;
RAIDRequest *newEvent;
IntVTime sendTime = dynamic_cast<const IntVTime&>(getSimulationTime());
int timeDelay = 1;
IntVTime ldelay(sendTime + timeDelay++);
int receiveDisk;
while(true == haveMoreEvents()) {
recvEvent = (RAIDRequest *) getEvent();
if ( recvEvent != NULL ) {
myState = (RAIDForkState*) getState();
newEvent = new RAIDRequest(sendTime, ldelay, this, this);
*newEvent = *recvEvent;
int firstStripeUnit = newEvent->getStartStripe();
ObjectID sourceObjId = *(getObjectHandle(recvEvent->getSourceObject())->getObjectID());
if ( recvEvent->getSender() == sourceObjId ) {
if (recvEvent->getRead() == true) {
int parityDiskId;
for (int count = 0; count < recvEvent->getSizeRead(); count++) {
newEvent->setStartStripe(firstStripeUnit + count);
calculateStripeInfo(newEvent, parityDiskId, receiveDisk);
delete newEvent;
newEvent = new RAIDRequest(sendTime, ldelay, this, outputHandles[receiveDisk]);
*newEvent = *recvEvent;
newEvent->setStartStripe(firstStripeUnit + count);
(outputHandles[receiveDisk])->receiveEvent(newEvent);
newEvent = new RAIDRequest(sendTime, ldelay, this, this );
*newEvent = *recvEvent;
}
if (newEvent->getSizeRead() > 0) {
delete newEvent; // Get rid of unused one
}
}
else {
// Its a write, so send the paritys.
// See how many parity messages needed.
int numParity = 0;
int parityDiskId;
// Kludge
// calculate the number of parity messages needed
int lastParityDiskId = -1;
int count;
for (count = 0; count < newEvent->getSizeRead(); count++) {
parityDiskId = getParityDiskId(firstStripeUnit + count);
if (parityDiskId != lastParityDiskId) {
numParity++;
lastParityDiskId = parityDiskId;
}
}
lastParityDiskId = -1;
for (count = 0; count < newEvent->getSizeRead(); count++) {
newEvent->setStartStripe(firstStripeUnit + count);
calculateStripeInfo(newEvent, parityDiskId, receiveDisk);
delete newEvent;
newEvent = new RAIDRequest( sendTime, ldelay, this, outputHandles[receiveDisk] );
*newEvent = *recvEvent;
newEvent->setStartStripe(firstStripeUnit + count );
newEvent->setParityMsg(false);
newEvent->setSizeParity(numParity);
// Do we need different parity block yet.
if (parityDiskId != lastParityDiskId) {
lastParityDiskId = parityDiskId;
RAIDRequest *parityMsg = new RAIDRequest(sendTime,
ldelay,
this,
outputHandles[parityDiskId%numberOfOutputs]);
// send a request for the new information.
*parityMsg = *newEvent;
parityMsg->setParityMsg(true);
(outputHandles[parityDiskId%numberOfOutputs])->receiveEvent(parityMsg);
}
(outputHandles[receiveDisk])->receiveEvent(newEvent);
newEvent = new RAIDRequest(sendTime,
ldelay,
this,
this);
*newEvent = *recvEvent;
}// for (count = 0; count < newEvent->sizeRead; count++)
delete newEvent; // Get rid of last unsent message
} // if (read)
} // if (sender == source)
} // End of if (event != null)
} // End of while "have more events" loop
} // End of executePRocess()
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
}
