Initial commit
This commit is contained in:
Matthias
Executable
+174
@@ -0,0 +1,174 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <wfr/common/types/ResourceTypes.h>
|
||||
#include <wfr/common/resource/ResourceCapabilities.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <initializer_list>
|
||||
|
||||
|
||||
namespace wfr {
|
||||
|
||||
// Forward declarations
|
||||
namespace wfs { class AtomicActivityImplementation; }
|
||||
|
||||
namespace resource {
|
||||
|
||||
|
||||
|
||||
class AbstractResource {
|
||||
|
||||
// Invariant properties that can be accessed directly.
|
||||
public:
|
||||
const ResourceClass resourceClass;
|
||||
const std::string resourceIdentifier;
|
||||
|
||||
// Public Functions
|
||||
public:
|
||||
AbstractResource( ResourceClass resourceClass, const std::string& resourceIdentifier ) noexcept
|
||||
: resourceClass(resourceClass), resourceIdentifier(resourceIdentifier) {}
|
||||
virtual ~AbstractResource() {}
|
||||
|
||||
virtual bool hasCapability(const RequiredResourceCapability& type) const noexcept = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
class AbstractResourceType {
|
||||
|
||||
// Invariant properties that can be accessed directly.
|
||||
public:
|
||||
const ResourceClass resourceClass;
|
||||
const std::string resourceTypeName;
|
||||
|
||||
// Mutable properties that need to be accessed via getter-/setter-functions.
|
||||
protected:
|
||||
std::set<ResourceCapability> capabilities;
|
||||
std::map<std::string, std::string> properties;
|
||||
|
||||
// Public Functions
|
||||
public:
|
||||
AbstractResourceType( ResourceClass resourceClass, const std::string& resourceName,
|
||||
const std::set<ResourceCapability>& capabilities = std::set<ResourceCapability>(),
|
||||
const std::map<std::string, std::string>& properties = std::map<std::string, std::string>() ) noexcept
|
||||
: resourceClass(resourceClass), resourceTypeName(resourceName), capabilities(capabilities), properties(properties) {}
|
||||
virtual ~AbstractResourceType() {}
|
||||
|
||||
wfr_size_t getCapabilityCount() const noexcept { return capabilities.size(); }
|
||||
const std::set<ResourceCapability>& getCapabilities() const noexcept { return capabilities; }
|
||||
bool hasCapability(const RequiredResourceCapability& type) const noexcept;
|
||||
bool hasCapability(wfr::resource::ResourceCapabilityType type) const noexcept;
|
||||
|
||||
wfr_size_t getPropertyCount() const noexcept { return properties.size(); }
|
||||
const std::map<std::string, std::string>& getProperties() const noexcept { return properties; }
|
||||
std::vector<std::string> getPropertyKeys() const noexcept;
|
||||
std::string getProperty(const std::string& key) const noexcept;
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<class Resource>
|
||||
class ResourceTypeBase : public AbstractResourceType {
|
||||
|
||||
// Mutable properties that need to be accessed via getter-/setter-functions.
|
||||
private:
|
||||
std::vector<Resource*> resources;
|
||||
|
||||
// Public Functions
|
||||
public:
|
||||
ResourceTypeBase( ResourceClass resourceClass, const std::string& resourceName,
|
||||
const std::set<ResourceCapability>& capabilities = std::set<ResourceCapability>(),
|
||||
const std::map<std::string, std::string>& properties = std::map<std::string, std::string>() ) noexcept
|
||||
: AbstractResourceType(resourceClass, resourceName, capabilities, properties) {}
|
||||
|
||||
wfr_size_t getResourceCount() const noexcept { return resources.size(); }
|
||||
const std::vector<Resource*> getResources() const noexcept { return resources; }
|
||||
void addResource(Resource* resource) noexcept { resources.push_back(resource); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<class RType>
|
||||
class ResourceBase : public AbstractResource {
|
||||
|
||||
// Invariant properties that can be accessed directly.
|
||||
public:
|
||||
RType& resourceType;
|
||||
|
||||
// Public Functions
|
||||
public:
|
||||
ResourceBase(ResourceClass resourceClass, const std::string& resourceIdentifier, RType& resourceType ) noexcept
|
||||
: AbstractResource(resourceClass, resourceIdentifier), resourceType(resourceType) {}
|
||||
|
||||
virtual bool hasCapability(const RequiredResourceCapability& type) const noexcept { return resourceType.hasCapability(type); }
|
||||
virtual bool hasCapability(wfr::resource::ResourceCapabilityType type) const noexcept { return resourceType.hasCapability(type); }
|
||||
};
|
||||
|
||||
|
||||
class ComputingResource;
|
||||
|
||||
class ComputingResourceType : public ResourceTypeBase<ComputingResource> {
|
||||
|
||||
// Invariant properties that can be accessed directly.
|
||||
public:
|
||||
const ComputingDeviceClass computingDeviceClass;
|
||||
const wfr_size_t maxSlots;
|
||||
|
||||
|
||||
// Public Functions
|
||||
public:
|
||||
ComputingResourceType( const std::string& resourceName, ComputingDeviceClass computingDeviceClass, wfr_size_t maxSlots,
|
||||
const std::set<ResourceCapability>& capabilities = std::set<ResourceCapability>(),
|
||||
const std::map<std::string, std::string>& properties = std::map<std::string, std::string>() ) noexcept
|
||||
: ResourceTypeBase(ResourceClass::ComputingResource, resourceName, capabilities, properties),
|
||||
computingDeviceClass(computingDeviceClass), maxSlots(maxSlots) {}
|
||||
};
|
||||
|
||||
|
||||
|
||||
class ComputingResource : public ResourceBase<ComputingResourceType> {
|
||||
|
||||
// Mutable properties that need to be accessed via getter-/setter-functions.
|
||||
protected:
|
||||
wfr_size_t reservedSlots =0;
|
||||
wfr_size_t busySlots = 0;
|
||||
|
||||
// Public Functions
|
||||
public:
|
||||
ComputingResource( const std::string& resourceIdentifier, ComputingResourceType& resourceType ) noexcept
|
||||
: ResourceBase(ResourceClass::ComputingResource, resourceIdentifier, resourceType) {
|
||||
resourceType.addResource(this);
|
||||
}
|
||||
|
||||
wfr_size_t getMaxSlotCount() const noexcept { return resourceType.maxSlots; }
|
||||
wfr_size_t getReservedSlotCount() const noexcept { return reservedSlots; }
|
||||
wfr_size_t getBusySlotCount() const noexcept { return busySlots; }
|
||||
wfr_size_t getFreeSlotCount() const noexcept { return resourceType.maxSlots - (busySlots + reservedSlots); }
|
||||
|
||||
bool reserveSlots(const wfr_size_t& slots) noexcept;
|
||||
bool markReservedSlotsBusy(const wfr_size_t& slots) noexcept;
|
||||
bool markFreeSlotsBusy(const wfr_size_t& slots) noexcept;
|
||||
bool releaseBusySlots(const wfr_size_t& slots) noexcept;
|
||||
};
|
||||
|
||||
|
||||
|
||||
ComputingDeviceClass parseComputingDeviceType(const std::string& type);
|
||||
|
||||
std::string getComputingDeviceTypeString(const ComputingDeviceClass& type);
|
||||
|
||||
|
||||
|
||||
ResourceCapabilityType parseResourceCapabilityType(const std::string& type);
|
||||
|
||||
std::string getResourceCapabilityTypeString(const ResourceCapabilityType& type);
|
||||
|
||||
|
||||
|
||||
} /* namespace resource */
|
||||
} /* namespace wfr */
|
||||
|
||||
|
||||
+108
@@ -0,0 +1,108 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <wfr/common/types/ResourceTypes.h>
|
||||
|
||||
|
||||
namespace wfr {
|
||||
namespace resource {
|
||||
|
||||
|
||||
/**
|
||||
* Represents the capabilities of a resource.
|
||||
*/
|
||||
class ResourceCapability {
|
||||
public:
|
||||
const ResourceCapabilityType type;
|
||||
const wfr_size_t majorVersion;
|
||||
const wfr_size_t minorVersion;
|
||||
|
||||
public:
|
||||
ResourceCapability()
|
||||
: type(ResourceCapabilityType::Unknown), majorVersion(0), minorVersion(0) {}
|
||||
|
||||
ResourceCapability(const ResourceCapabilityType& type, const wfr_size_t& majorVersion, const wfr_size_t& minorVersion)
|
||||
: type(type), majorVersion(majorVersion), minorVersion(minorVersion) {}
|
||||
|
||||
|
||||
static ResourceCapability GenericCPU() {
|
||||
return ResourceCapability(ResourceCapabilityType::GenericCPU, 0, 0);
|
||||
}
|
||||
|
||||
static ResourceCapability OpenCL(const wfr_size_t& majorVersion, const wfr_size_t& minorVersion) {
|
||||
return ResourceCapability(ResourceCapabilityType::OpenCL, majorVersion, minorVersion);
|
||||
}
|
||||
|
||||
static ResourceCapability CUDA(const wfr_size_t& majorVersion, const wfr_size_t& minorVersion) {
|
||||
return ResourceCapability(ResourceCapabilityType::CUDA, majorVersion, minorVersion);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Represents the requirements of an activity implementation.
|
||||
**/
|
||||
class RequiredResourceCapability {
|
||||
public:
|
||||
const ResourceCapabilityType type;
|
||||
const wfr_size_t minMajorVersion;
|
||||
const wfr_size_t minMinorVersion;
|
||||
const wfr_size_t maxMajorVersion;
|
||||
const wfr_size_t maxMinorVersion;
|
||||
|
||||
public:
|
||||
RequiredResourceCapability()
|
||||
: type(ResourceCapabilityType::Unknown), minMajorVersion(0), minMinorVersion(0), maxMajorVersion(0), maxMinorVersion(0) {}
|
||||
|
||||
RequiredResourceCapability(const ResourceCapabilityType& type, const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion,
|
||||
const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0)
|
||||
: type(type), minMajorVersion(minMajorVersion), minMinorVersion(minMinorVersion),
|
||||
maxMajorVersion(maxMajorVersion), maxMinorVersion(maxMinorVersion) {}
|
||||
|
||||
|
||||
static RequiredResourceCapability GenericCPU() {
|
||||
return RequiredResourceCapability(ResourceCapabilityType::GenericCPU, 0, 0, 0, 0);
|
||||
}
|
||||
|
||||
static RequiredResourceCapability OpenCL(const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion,
|
||||
const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0) {
|
||||
return RequiredResourceCapability(ResourceCapabilityType::OpenCL, minMajorVersion, minMinorVersion, maxMajorVersion, maxMinorVersion);
|
||||
}
|
||||
|
||||
static RequiredResourceCapability CUDA(const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion,
|
||||
const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0) {
|
||||
return RequiredResourceCapability(ResourceCapabilityType::CUDA, minMajorVersion, minMinorVersion, maxMajorVersion, maxMinorVersion);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
typedef std::initializer_list<resource::ResourceCapability> CapabilityList;
|
||||
typedef std::initializer_list<resource::RequiredResourceCapability> RequiredCapabilityList;
|
||||
|
||||
inline bool operator<(const wfr::resource::ResourceCapability& dev1, const wfr::resource::ResourceCapability& dev2) {
|
||||
if (dev1.type == dev2.type) {
|
||||
if (dev1.majorVersion == dev2.majorVersion) {
|
||||
return dev1.minorVersion < dev2.minorVersion;
|
||||
} else {
|
||||
return dev1.majorVersion < dev2.majorVersion;
|
||||
}
|
||||
} else {
|
||||
return dev1.type < dev2.type;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool operator==(const wfr::resource::ResourceCapability& cap, const wfr::resource::RequiredResourceCapability& rcap) {
|
||||
if (cap.type == rcap.type) {
|
||||
if (cap.majorVersion >= rcap.minMajorVersion && cap.majorVersion <= rcap.maxMajorVersion) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
} /* namespace resource */
|
||||
} /* namespace wfr */
|
||||
|
||||
+69
@@ -0,0 +1,69 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
#include <utility>
|
||||
#include <queue>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <atomic>
|
||||
#include <ostream>
|
||||
#include <wfr/common/types/WfrTypes.h>
|
||||
#include <wfr/common/types/ResourceTypes.h>
|
||||
|
||||
|
||||
namespace wfr {
|
||||
namespace resource {
|
||||
|
||||
class AbstractResource;
|
||||
class ComputingResource;
|
||||
class ComputingResourceType;
|
||||
class ComputingResourceReservation;
|
||||
class RequiredResourceCapability;
|
||||
|
||||
class ResourceManager {
|
||||
private:
|
||||
static ResourceManager* singleton;
|
||||
|
||||
// Mutable properties that need to be accessed via getter-/setter-functions.
|
||||
private:
|
||||
std::mutex managerMutex;
|
||||
std::map<std::string, ComputingResourceType*> computingResourceTypes;
|
||||
std::map<std::string, ComputingResource*> computingResources;
|
||||
|
||||
// Non-public functions
|
||||
private:
|
||||
ResourceManager(std::string resourceConfigFile, bool cpuAutoConfig, bool printResourceTable);
|
||||
|
||||
void readConfigFile(std::string configFile);
|
||||
|
||||
// Public static functions
|
||||
public:
|
||||
static void init(int argc, char** argv);
|
||||
static void finish() noexcept;
|
||||
static ResourceManager& getInstance() noexcept;
|
||||
|
||||
// Public functions
|
||||
public:
|
||||
~ResourceManager() noexcept;
|
||||
|
||||
wfr_size_t getComputingResourceCount() const noexcept { return computingResources.size(); }
|
||||
std::vector<ComputingResource*> getComputingResources() const noexcept;
|
||||
ComputingResource* getComputingResource(std::string identifier) const noexcept;
|
||||
std::vector<ComputingResource*> filterComputingResources(std::vector<RequiredResourceCapability> filter) const noexcept;
|
||||
|
||||
ComputingResourceReservation reserveComputingResource(ComputingResource* device, const wfr_size_t& slots = 1) noexcept;
|
||||
bool releaseComputingResources(ComputingResourceReservation* handle) noexcept;
|
||||
|
||||
wfr_size_t getComputingResourceTypeCount() const noexcept { return computingResourceTypes.size(); }
|
||||
std::vector<ComputingResourceType*> getComputingResourceTypes() const noexcept;
|
||||
ComputingResourceType* getComputingResourceType(std::string name) const noexcept;
|
||||
|
||||
void printResourceTable(std::ostream& out) const noexcept;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace resource */
|
||||
} /* namespace wfr */
|
||||
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <wfr/common/types/WfrTypes.h>
|
||||
|
||||
namespace wfr {
|
||||
namespace resource {
|
||||
|
||||
class ComputingResource;
|
||||
|
||||
class ComputingResourceReservation {
|
||||
|
||||
// Invariant properties that can be accessed directly.
|
||||
public:
|
||||
resource::ComputingResource* const resource = nullptr;
|
||||
const wfr_size_t slotCount = 0;
|
||||
|
||||
// Mutable properties that need to be accessed via getter-/setter-functions.
|
||||
protected:
|
||||
bool isValidFlag = false;
|
||||
|
||||
// Public Functions
|
||||
public:
|
||||
ComputingResourceReservation() noexcept {}
|
||||
ComputingResourceReservation(resource::ComputingResource* resource, const wfr_size_t& slotCount = 1) noexcept
|
||||
: resource(resource), slotCount(slotCount), isValidFlag(true) {}
|
||||
virtual ~ComputingResourceReservation() noexcept {}
|
||||
|
||||
bool isValid() const noexcept { return isValidFlag; }
|
||||
void invalidateReservation() noexcept { isValidFlag = false; }
|
||||
};
|
||||
|
||||
} /* namespace resource */
|
||||
} /* namespace wfr */
|
||||
|
||||
Reference in New Issue
Block a user