Support object subtype query in remote device

KhronosGroup · Jul 21, 2023 · 80d6dd9 · 80d6dd9
1 parent 2174ee2
commit 80d6dd9
Show file tree

Hide file tree

Showing 4 changed files with 110 additions and 1 deletion.
diff --git a/libs/remote_device/Device.cpp b/libs/remote_device/Device.cpp
@@ -439,7 +439,31 @@ int Device::getProperty(ANARIObject object,
 
 const char ** Device::getObjectSubtypes(ANARIDataType objectType)
 {
-  return nullptr;
+  auto it = std::find_if(objectSubtypes.begin(),
+      objectSubtypes.end(),
+      [objectType](const ObjectSubtypes &os) {
+        return os.objectType == objectType;
+      });
+  if (it != objectSubtypes.end()) {
+    return (const char **)it->value.data();
+  }
+
+  auto buf = std::make_shared<Buffer>();
+  buf->write((const char *)&remoteDevice, sizeof(remoteDevice));
+  buf->write((const char *)&objectType, sizeof(objectType));
+  write(MessageType::GetObjectSubtypes, buf);
+
+  std::unique_lock l(syncObjectSubtypes.mtx);
+  syncObjectSubtypes.cv.wait(l, [this, &it, objectType]() {
+    it = std::find_if(objectSubtypes.begin(),
+      objectSubtypes.end(),
+      [&it, objectType](const ObjectSubtypes &os) {
+        return os.objectType == objectType;
+      });
+    return it != objectSubtypes.end();
+  });
+
+  return (const char **)it->value.data();
 }
 
 const void* Device::getObjectInfo(ANARIDataType objectType,
@@ -621,6 +645,12 @@ Device::~Device()
       delete[] stringListProperties[i].value[j];
     }
   }
+
+  for (size_t i = 0; i < objectSubtypes.size(); ++i) {
+    for (size_t j = 0; j < objectSubtypes[i].value.size(); ++j) {
+      delete[] objectSubtypes[i].value[j];
+    }
+  }
 }
 
 ANARIObject Device::registerNewObject(ANARIDataType type, std::string subtype)
@@ -896,6 +926,32 @@ void Device::handleMessage(async::connection::reason reason,
       syncProperties.cv.notify_all();
 
       // LOG(logging::Level::Info) << "Property: " << property.name;
+    } else if (message->type() == MessageType::ObjectSubtypes) {
+      std::unique_lock l(syncObjectSubtypes.mtx);
+
+      Buffer buf;
+      buf.write(message->data(), message->size());
+      buf.seek(0);
+
+      ObjectSubtypes os;
+
+      buf.read((char *)&os.objectType, sizeof(os.objectType));
+
+      while (!buf.eof()) {
+        uint64_t strLen;
+        buf.read((char *)&strLen, sizeof(strLen));
+
+        char *subtype = new char[strLen + 1];
+        buf.read(subtype, strLen);
+        subtype[strLen] = '\0';
+        os.value.push_back(subtype);
+      }
+      os.value.push_back(nullptr);
+
+      objectSubtypes.push_back(os);
+
+      l.unlock();
+      syncObjectSubtypes.cv.notify_all();
     } else if (message->type() == MessageType::ChannelColor
         || message->type() == MessageType::ChannelDepth) {
       size_t off = 0;

diff --git a/libs/remote_device/Device.h b/libs/remote_device/Device.h
@@ -212,6 +212,12 @@ struct Device : anari::DeviceImpl, helium::ParameterizedObject
     size_t which;
   } syncProperties;
 
+  struct
+  {
+    std::mutex mtx;
+    std::condition_variable cv;
+  } syncObjectSubtypes;
+
   ANARIDevice remoteDevice{nullptr};
   std::string remoteSubtype = "default";
 
@@ -237,6 +243,15 @@ struct Device : anari::DeviceImpl, helium::ParameterizedObject
   };
   std::vector<StringListProperty> stringListProperties;
 
+  // Store subtypes; if the subtype was already queried,
+  // simply return the cached subtype list
+  struct ObjectSubtypes
+  {
+    ANARIDataType objectType;
+    std::vector<char *> value;
+  };
+  std::vector<ObjectSubtypes> objectSubtypes;
+
   std::map<ANARIObject, Frame> frames;
   std::map<ANARIArray, std::vector<char>> arrays;
 

diff --git a/libs/remote_device/Server.cpp b/libs/remote_device/Server.cpp
@@ -970,6 +970,42 @@ struct Server
           outbuf->write((const char *)mem.data(), size);
         }
         write(MessageType::Property, outbuf);
+      } else if (message->type() == MessageType::GetObjectSubtypes) {
+        LOG(logging::Level::Info) << "Message: GetObjectSubtypes, message size: "
+                                  << prettyBytes(message->size());
+
+        Buffer buf;
+        buf.write(message->data(), message->size());
+        buf.seek(0);
+
+        Handle deviceHandle;
+        buf.read((char *)&deviceHandle, sizeof(deviceHandle));
+
+        ANARIDataType objectType;
+        buf.read((char *)&objectType, sizeof(objectType));
+
+        ANARIDevice dev = resourceManager.getDevice(deviceHandle);
+
+        if (!dev) {
+          LOG(logging::Level::Error)
+              << "Server: invalid device: " << deviceHandle;
+          // manager->stop(); // legal?
+          return;
+        }
+
+        auto outbuf = std::make_shared<Buffer>();
+        outbuf->write((const char *)&objectType, sizeof(objectType));
+
+        const char **subtypes = anariGetObjectSubtypes(dev, objectType);
+
+        if (subtypes != nullptr) {
+          while (const char *str = *subtypes++) {
+            uint64_t strLen = strlen(str);
+            outbuf->write((const char *)&strLen, sizeof(strLen));
+            outbuf->write(str, strLen);
+          }
+        }
+        write(MessageType::ObjectSubtypes, outbuf);
       } else {
         LOG(logging::Level::Warning)
             << "Unhandled message of size: " << message->size();

diff --git a/libs/remote_device/common.h b/libs/remote_device/common.h
@@ -40,6 +40,8 @@ struct MessageType
     FrameIsReady,
     GetProperty,
     Property,
+    GetObjectSubtypes,
+    ObjectSubtypes,
     ChannelColor,
     ChannelDepth,
   };