void ResourceHosting::discoveryHandler(RemoteObjectPtr remoteResource)
{
std::cout << "ResourceHosting: Discovered device with uri: " << remoteResource->getUri() << std::endl;
auto discoverdUri = remoteResource->getUri();
if (discoverdUri.compare(
discoverdUri.size()-HOSTING_TAG_SIZE, HOSTING_TAG_SIZE, HOSTING_TAG) != 0)
{
return;
}
auto foundHostingObject = findRemoteResource(remoteResource);
if (foundHostingObject != nullptr) return;
try
{
HostingObjectKey key = generateHostingObjectKey(remoteResource);
foundHostingObject = HostingObject::createHostingObject(remoteResource,
std::bind(&ResourceHosting::destroyedHostingObject, this, key));
RHLock lock(m_mutexForList);
m_hostingObjects.insert(std::make_pair(key, foundHostingObject));
} catch (const RCSException & e)
{
OIC_HOSTING_LOG(DEBUG,
"[ResourceHosting::discoverHandler]InvalidParameterException:%s", e.what());
}
}
HostingObject::ResourceObjectPtr HostingObject::createMirroredServer(RemoteObjectPtr rObject)
{
ResourceObjectPtr retResource = nullptr;
if(rObject != nullptr)
{
std::string fulluri = rObject->getUri();
std::string uri = fulluri.substr(0, fulluri.size()-8);
std::vector<std::string> types = rObject->getTypes();
std::vector<std::string> interfaces = rObject->getInterfaces();
try
{
std::string type = types.begin()->c_str();
std::string interface = interfaces.begin()->c_str();
retResource = RCSResourceObject::Builder(uri, type, interface).
setDiscoverable(true).setObservable(true).build();
// TODO need to bind types and interfaces
retResource->setAutoNotifyPolicy(RCSResourceObject::AutoNotifyPolicy::UPDATED);
retResource->setSetRequestHandler(pSetRequestHandler);
}catch(...)
{
OIC_HOSTING_LOG(DEBUG, "[HostingObject::createMirroredServer] %s", "PlatformException");
throw;
}
}
else
{
throw PlatformException(OC_STACK_ERROR);
}
return retResource;
}
bool ResourceHosting::isSameRemoteResource(
RemoteObjectPtr remoteResource_1, RemoteObjectPtr remoteResource_2)
{
bool ret = false;
if(remoteResource_1->getAddress() == remoteResource_2->getAddress() &&
remoteResource_1->getUri() == remoteResource_2->getUri())
{
ret = true;
}
return ret;
}
void petabricks::RemoteHost::createRemoteObject(const RemoteObjectPtr& local,
RemoteObjectGenerator remote,
const void* data, size_t len){
local->markInitiatorMu();
local->setHostMu(this);
GeneralMessage msg = { MessageTypes::REMOTEOBJECT_CREATE,
0,
len,
EncodeDataPtr(local.asPtr()),
EncodeTextPtr(remote) };
sendMsg(&msg, data, len);
JLOCKSCOPE(_controlmu);
_objects.push_back(local);
}
void ResourceHosting::discoverHandler(RemoteObjectPtr remoteResource)
{
std::string discoverdUri = remoteResource->getUri();
if(discoverdUri.compare(
discoverdUri.size()-HOSTING_TAG_SIZE, HOSTING_TAG_SIZE, HOSTING_TAG) != 0)
{
return;
}
HostingObjectPtr foundHostingObject = findRemoteResource(remoteResource);
if(foundHostingObject == nullptr)
{
try
{
foundHostingObject = std::make_shared<HostingObject>();
foundHostingObject->initializeHostingObject(remoteResource,
std::bind(&ResourceHosting::destroyedHostingObject, this,
HostingObjectWeakPtr(foundHostingObject)));
hostingObjectList.push_back(foundHostingObject);
}catch(const RCSInvalidParameterException &e)
{
OIC_HOSTING_LOG(DEBUG,
"[ResourceHosting::discoverHandler]InvalidParameterException:%s", e.what());
}
}
}
void HostingObject::stateChangedCB(ResourceState state, RemoteObjectPtr rObject)
{
remoteState = state;
switch (state)
{
case ResourceState::ALIVE:
{
if(rObject->isCaching() == false)
{
try
{
rObject->startCaching(pDataUpdateCB);
}catch(InvalidParameterException &e)
{
OIC_HOSTING_LOG(DEBUG,
"[HostingObject::stateChangedCB]startCaching InvalidParameterException:%s",
e.what());
}
}
break;
}
case ResourceState::LOST_SIGNAL:
case ResourceState::DESTROYED:
{
if(rObject->isCaching() == true)
{
try
{
rObject->stopCaching();
}catch(InvalidParameterException &e)
{
OIC_HOSTING_LOG(DEBUG,
"[HostingObject::stateChangedCB]stopCaching InvalidParameterException:%s",
e.what());
}
}
if(rObject->isMonitoring() == true)
{
try
{
rObject->stopMonitoring();
}catch(InvalidParameterException &e)
{
OIC_HOSTING_LOG(DEBUG,
"[HostingObject::stateChangedCB]stopWatching InvalidParameterException:%s",
e.what());
}
}
mirroredServer = nullptr;
destroyHostingObject();
break;
}
default:
// not support of state
break;
}
}
int main(int argc, const char** argv){
const char* filename = "testdata/Helmholtz3DB1";
IndexT m1[] = {1,1,1};
IndexT m123[] = {1,2,3};
IndexT m456[] = {4,5,6};
IndexT m2[] = {2,2,2};
IndexT m3[] = {3,3,3};
IndexT m234[] = {2,3,4};
IndexT size[] = {8,9,8};
//
// Create a RegionMatrix
MatrixRegion3D regionMatrix(size);
if(argc==1){
printf("main %d\n", getpid());
RemoteHostDB::instance().remotefork(NULL, argc, argv);
RemoteHostDB::instance().accept("");
RemoteHostDB::instance().spawnListenThread();
// Split the matrix in to multiple parts of size m2
regionMatrix.splitData(m2);
// Assign a chunk of data to remote host
// - put part 0 in hdb.host(0)
// - the other parts are created locally
regionMatrix.createDataPart(0, RemoteHostDB::instance().host(0));
// import data
MatrixRegion3D in = MatrixIO(filename,"r").read_distributed<3>();
regionMatrix.copyDataFromRegion(in);
// or, allocate empty matrix
// regionMatrix->allocData();
printf("== data should be in 2 hosts ==\n");
regionMatrix.printDataHosts();
CellProxy cell = regionMatrix.cell(m234);
JASSERT(fabs(cell - 0.52076837) < 0.00000001);
cell = 5;
JASSERT(fabs(cell - 5) < 0.00000001);
// Test split
MatrixRegion3D split3 = regionMatrix.region(m123, m456);
printf("== region((1,2,3), (4,5,6)) : will send this to process2 ==\n");
MatrixIO().write(split3);
split3.printDataHosts();
MatrixRegion3D split2 = split3.region(m1, m3);
printf("== region((1,1,1), (3,3,3)) ==\n");
MatrixIO().write(split2);
split2.printDataHosts();
MatrixRegion2D slice1 = split2.slice(2, 0);
printf("== slice(2,0) ==\n");
MatrixIO().write(slice1);
slice1.printDataHosts();
MatrixRegion1D slice2 = slice1.slice(1, 1);
printf("== slice(1,1) ==\n");
MatrixIO().write(slice2);
slice2.printDataHosts();
// Test slice
MatrixRegion2D slice3 = regionMatrix.slice(1, 0);
printf("== slice(1,0) of original matrix ==\n");
MatrixIO().write(slice3);
slice3.printDataHosts();
///////////////////////////////////
// Migrate to process 2
char* buf = new char[split3.serialSize()];
split3.serialize(buf, *RemoteHostDB::instance().host(0));
RemoteObjectPtr local;
RemoteHostDB::instance().host(0)->createRemoteObject(local=gen(), &gen);
local->waitUntilCreated();
local->send(buf, split3.serialSize());
printf("== sent matrix to process2 ==\n");
RemoteHostDB::instance().listenLoop();
return 0;
} else {
printf("main2 %d\n", getpid());
JASSERT(argc==3);
RemoteHostDB::instance().connect(argv[1], jalib::StringToInt(argv[2]));
RemoteHostDB::instance().spawnListenThread();
RemoteHostDB::instance().listenLoop();
return 0;
}
}
bool petabricks::RemoteHost::recv() {
GeneralMessage msg;
if(!_controlmu.trylock()) {
JTRACE("skipping recv, locked");
return false;
}
ssize_t cnt = _control.tryReadAll((char*)&msg, sizeof msg);
if(cnt==0) {
_controlmu.unlock();
return false;
}
if(cnt<0) {
_controlmu.unlock();
JASSERT(false)(_id).Text("disconnected");
return false;
}
JASSERT(cnt==sizeof msg)(cnt);
if(msg.len>0){
JASSERT(msg.chan>=0 && msg.chan<REMOTEHOST_DATACHANS);
_datamu[msg.chan].lock();
}
_controlmu.unlock();
RemoteObjectGenerator gen = 0;
RemoteObjectPtr obj = 0;
void* buf = 0;
switch(msg.type) {
case MessageTypes::REMOTEOBJECT_CREATE:
{
gen = DecodeTextPtr<RemoteObjectGenerator>(msg.dstptr);
obj = (*gen)();
JLOCKSCOPE(*obj);
obj->setHostMu(this);
obj->setRemoteObjMu(msg.srcptr);
if(msg.len>0){
buf = obj->allocRecvInitial(msg.len);
_data[msg.chan].readAll((char*)buf, msg.len);
_datamu[msg.chan].unlock();
obj->onRecvInitial(buf, msg.len);
obj->freeRecvInitial(buf, msg.len);
}
obj->onCreated();
obj->markCreatedMu();
{ GeneralMessage ackmsg = { MessageTypes::REMOTEOBJECT_CREATE_ACK, 0, 0, EncodeDataPtr(obj.asPtr()), msg.srcptr };
sendMsg(&ackmsg);
}
JLOCKSCOPE(_controlmu);
_objects.push_back(obj);
break;
}
case MessageTypes::REMOTEOBJECT_CREATE_ACK:
{
obj = DecodeDataPtr<RemoteObject>(msg.dstptr);
JASSERT(msg.len==0);
JLOCKSCOPE(*obj);
obj->setRemoteObjMu(msg.srcptr);
obj->onCreated();
obj->markCreatedMu();
break;
}
case MessageTypes::REMOTEOBJECT_DATA:
{
obj = DecodeDataPtr<RemoteObject>(msg.dstptr);
JLOCKSCOPE(*obj);
if(msg.len>0){
buf = obj->allocRecv(msg.len);
_data[msg.chan].readAll((char*)buf, msg.len);
_datamu[msg.chan].unlock();
obj->onRecv(buf, msg.len);
obj->freeRecv(buf, msg.len);
}
break;
}
case MessageTypes::REMOTEOBJECT_SIGNAL:
{
obj = DecodeDataPtr<RemoteObject>(msg.dstptr);
JASSERT(msg.len==0);
JLOCKSCOPE(*obj);
obj->signal();
break;
}
case MessageTypes::REMOTEOBJECT_BROADCAST:
{
obj = DecodeDataPtr<RemoteObject>(msg.dstptr);
JASSERT(msg.len==0);
JLOCKSCOPE(*obj);
obj->broadcast();
break;
}
case MessageTypes::REMOTEOBJECT_NOTIFY:
{
obj = DecodeDataPtr<RemoteObject>(msg.dstptr);
JASSERT(msg.len==0);
JLOCKSCOPE(*obj);
obj->onNotify(msg.srcptr);
break;
}
case MessageTypes::REMOTEOBJECT_MARKCOMPLETE:
{
obj = DecodeDataPtr<RemoteObject>(msg.dstptr);
JASSERT(msg.len==0);
JLOCKSCOPE(*obj);
obj->onComplete();
obj->markCompleteMu();
break;
}
default:
JASSERT(false);
}
return true;
}
ResourceHosting::HostingObjectKey ResourceHosting::generateHostingObjectKey(
RemoteObjectPtr rResource)
{
return generateHostingObjectKey(rResource->getAddress(), rResource->getUri());
}
