Skip to content
Snippets Groups Projects
Commit 9f1b7cb1 authored by cmaffeo2's avatar cmaffeo2
Browse files

Add documentation

parent 937ba1b3
No related branches found
No related tags found
1 merge request!3Fix issue with templated callSync function so that it can be used easily on...
......@@ -161,7 +161,6 @@ private:
std::vector<std::unique_ptr<PatchOp>> nonlocal_computes; // Operations that will be performed on this patch each timestep
// CPU particle arrays
struct Data {
VectorArr* pos_force;
VectorArr* momentum;
......
......@@ -3,16 +3,24 @@
#include <iostream>
#include "ARBDException.h"
/**
* @brief Represents a resource that can store data and perform computations.
*/
struct Resource {
// Represents something that can store data and compute things
/**
* @brief Enum to specify the type of the resource (e.g., CPU or GPU).
*/
enum ResourceType {CPU, GPU};
ResourceType type;
size_t id; // maybe something else
ResourceType type; ///< Type of the resource.
size_t id; ///< ID or any other identifier associated with the resource.
// HOST DEVICE static bool is_local() { // check if thread/gpu idx matches some global idx };
};
// START traits
// https://stackoverflow.com/questions/55191505/c-compile-time-check-if-method-exists-in-template-type
/**
* @brief Template trait to check if a method 'send_children' exists in a type.
*/
#include <type_traits>
template <typename T, typename = void>
struct has_send_children : std::false_type {};
......@@ -22,20 +30,42 @@ struct has_send_children<T, decltype(std::declval<T>().send_children(Resource{Re
// END traits
// Template argument is concrete class with data to be proxied
// 'Proxy' is probably a bad name because this is not quite the GoF Proxy Pattern
/**
* @brief Template class representing a proxy for the underlying data.
* @tparam T The type of the underlying data.
*/
template<typename T>
class Proxy {
public:
/**
* @brief Default constructor initializes the location to a default CPU resource and the address to nullptr.
*/
Proxy<T>() : location(Resource{Resource::CPU,0}), addr(nullptr) {};
Proxy<T>(const Resource& r, T* obj) : location(r), addr(obj) {};
/**
* @brief Overloaded operator-> returns the address of the underlying object.
* @return The address of the underlying object.
*/
auto operator->() { return addr; }
auto operator->() const { return addr; }
Resource location;
T* addr;
};
/**
* @brief The resource associated with the data represented by the proxy.
*/
Resource location; ///< The device (thread/gpu) holding the data represented by the proxy.
T* addr; ///< The address of the underlying object.
};
/**
* @brief Template function to send data ignoring children to a specified location.
* @tparam T The type of the data to be sent.
* @param location The destination resource for the data.
* @param obj The data to be sent.
* @param dest Optional parameter to provide a pre-allocated destination. If not provided, memory is allocated.
* @return A Proxy representing the data at the destination location.
*/
template <typename T>
HOST inline Proxy<T> _send_ignoring_children(const Resource& location, T& obj, T* dest = nullptr) {
switch (location.type) {
......@@ -58,7 +88,15 @@ HOST inline Proxy<T> _send_ignoring_children(const Resource& location, T& obj, T
return Proxy<T>(location, dest);
}
// This ugly template allows overloading copy_to_cuda, depending on whether T.copy_to_cuda exists using C++14-compatible SFINAE
/**
* @brief Template function to send simple objects to a specified location without considering child objects.
* This version will be selected upon send(location, obj) if obj.send_children does not exist (C++14-compatible SFINAE)
* @tparam T The type of the data to be sent.
* @param location The destination resource for the data.
* @param obj The data to be sent.
* @param dest Optional parameter to provide a pre-allocated destination. If not provided, memory is allocated.
* @return A Proxy representing the data at the destination location.
*/
template <typename T, typename Dummy = void, typename std::enable_if_t<!has_send_children<T>::value, Dummy>* = nullptr>
HOST inline Proxy<T> send(const Resource& location, T& obj, T* dest = nullptr) {
printf("Sending object %s @%x to device at %x\n", type_name<T>().c_str(), &obj, dest);
......@@ -69,6 +107,15 @@ HOST inline Proxy<T> send(const Resource& location, T& obj, T* dest = nullptr) {
return ret;
}
/**
* @brief Template function to send more complex objects to a specified location.
* This version will be selected upon send(location, obj) if obj.send_children exists (C++14-compatible SFINAE)
* @tparam T The type of the data to be sent.
* @param location The destination resource for the data.
* @param obj The data to be sent.
* @param dest Optional parameter to provide a pre-allocated destination. If not provided, memory is allocated on the GPU.
* @return A Proxy representing the data at the destination location.
*/
template <typename T, typename Dummy = void, typename std::enable_if_t<has_send_children<T>::value, Dummy>* = nullptr>
HOST inline Proxy<T> send(const Resource& location, T& obj, T* dest = nullptr) {
printf("Sending object %s @%x to device at %x\n", type_name<T>().c_str(), &obj, dest);
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment