hayodea
d217354689
Gave me some ideas about how things should be structured. Apparently merely using region-data-locked threads doesn't eliminate the need for synchronization/locking. It just means your synchronization is much lighter, in the form of localized variables. It seems we'll need to maintain boolean trackers for certain operations that shouldn't be performed concomitantly, and deny the caller access to those operations in order to preserve data sanity. I guess we still ended up using locking after all. Tbh, I'm not even sure this will make things end up being lighter: we may have to bounce requests off, or perhaps re-enqueue them into the queue? So maybe instead of bouncing requests off, we could re-add them to the rear of the queue when they conflict with an ongoing request.
115 lines
3.0 KiB
C++
115 lines
3.0 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <sstream>
|
|
#include <memory>
|
|
#include <opts.h>
|
|
#include <deviceManager/deviceManager.h>
|
|
#include <senseApis/senseApiManager.h>
|
|
|
|
namespace smo {
|
|
namespace device {
|
|
|
|
std::vector<std::shared_ptr<InteroceptorDevAttachmentSpec>>
|
|
DeviceManager::interoceptorDeviceSpecs;
|
|
std::vector<std::shared_ptr<ExtrospectorDevAttachmentSpec>>
|
|
DeviceManager::extrospectorDeviceSpecs;
|
|
std::vector<std::shared_ptr<DeviceAttachmentSpec>>
|
|
DeviceManager::deviceAttachmentSpecs;
|
|
std::vector<std::shared_ptr<Device>>
|
|
DeviceManager::devices;
|
|
|
|
// Async continuation structure
|
|
struct DeviceAttachmentContinuation {
|
|
std::shared_ptr<DeviceAttachmentSpec> spec;
|
|
std::function<void(
|
|
bool success, std::shared_ptr<Device> device,
|
|
std::shared_ptr<DeviceAttachmentSpec> deviceSpec)
|
|
> callback;
|
|
|
|
DeviceAttachmentContinuation(
|
|
std::shared_ptr<DeviceAttachmentSpec> s,
|
|
std::function<void(
|
|
bool success, std::shared_ptr<Device> device,
|
|
std::shared_ptr<DeviceAttachmentSpec> deviceSpec)
|
|
> cb)
|
|
: spec(s), callback(cb)
|
|
{}
|
|
};
|
|
|
|
const std::string DeviceManager::stringifyDeviceSpecs(void)
|
|
{
|
|
std::ostringstream oss;
|
|
|
|
for (const auto& spec : DeviceManager::interoceptorDeviceSpecs) {
|
|
oss << "Interoceptor " << spec->stringify();
|
|
}
|
|
|
|
for (const auto& spec : DeviceManager::extrospectorDeviceSpecs) {
|
|
oss << "Extrospector " << spec->stringify();
|
|
}
|
|
|
|
return oss.str();
|
|
}
|
|
|
|
void DeviceManager::newDeviceAttachmentSpecInd(
|
|
std::shared_ptr<DeviceAttachmentSpec> spec,
|
|
std::function<void(
|
|
bool success, std::shared_ptr<Device> device,
|
|
std::shared_ptr<DeviceAttachmentSpec> deviceSpec)
|
|
> callback)
|
|
{
|
|
// Create async continuation
|
|
auto continuation = std::make_shared<DeviceAttachmentContinuation>(
|
|
spec, callback);
|
|
|
|
// Check if a DeviceAttachmentSpec already matches
|
|
for (const auto& existingSpec : deviceAttachmentSpecs)
|
|
{
|
|
if (!(*existingSpec == *spec)) { continue; }
|
|
// Already exists, callback with error
|
|
callback(false, nullptr, nullptr);
|
|
return;
|
|
}
|
|
|
|
// Try to attach the sense device
|
|
try {
|
|
sense_api::SenseApiManager::getInstance().attachSenseDevice(spec);
|
|
|
|
// Look for existing Device with same identifier
|
|
std::shared_ptr<Device> device = nullptr;
|
|
for (const auto& existingDevice : devices)
|
|
{
|
|
if (existingDevice->deviceIdentifier != spec->deviceIdentifier)
|
|
{ continue; }
|
|
|
|
device = existingDevice;
|
|
break;
|
|
}
|
|
|
|
// If device doesn't exist, create a new one and add it
|
|
if (!device)
|
|
{
|
|
device = std::make_shared<Device>(spec->deviceIdentifier);
|
|
devices.push_back(device);
|
|
}
|
|
|
|
// Add DeviceAttachmentSpec to device's list
|
|
device->deviceAttachmentSpecs.push_back(spec);
|
|
|
|
// Add DeviceAttachmentSpec to DeviceManager's list
|
|
deviceAttachmentSpecs.push_back(spec);
|
|
|
|
// Callback with success
|
|
callback(true, device, spec);
|
|
} catch (const std::exception& e) {
|
|
// Attach failed, callback with error
|
|
callback(false, nullptr, nullptr);
|
|
}
|
|
}
|
|
|
|
} // namespace device
|
|
} // namespace smo
|