.. _program_listing_file_include_flamegpu_simulation_detail_CUDAEnvironmentDirectedGraphBuffers.cuh:

Program Listing for File CUDAEnvironmentDirectedGraphBuffers.cuh
================================================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_flamegpu_simulation_detail_CUDAEnvironmentDirectedGraphBuffers.cuh>` (``include/flamegpu/simulation/detail/CUDAEnvironmentDirectedGraphBuffers.cuh``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef INCLUDE_FLAMEGPU_SIMULATION_DETAIL_CUDAENVIRONMENTDIRECTEDGRAPHBUFFERS_CUH_
   #define INCLUDE_FLAMEGPU_SIMULATION_DETAIL_CUDAENVIRONMENTDIRECTEDGRAPHBUFFERS_CUH_
   
   #include <string>
   #include <map>
   #include <list>
   #include <memory>
   #include <vector>
   #include <unordered_map>
   #include <utility>
   #include <limits>
   
   #include "flamegpu/model/EnvironmentDirectedGraphData.cuh"
   #include "flamegpu/defines.h"
   #include "flamegpu/simulation/detail/CUDAErrorChecking.cuh"
   #include "flamegpu/detail/type_decode.h"
   #include "flamegpu/util/StringPair.h"
   namespace flamegpu {
   #ifdef FLAMEGPU_VISUALISATION
   namespace visualiser {
   struct ModelVisData;
   }
   #endif
   namespace detail {
   class CUDAScatter;
   namespace curve {
   class HostCurve;
   class CurveRTCHost;
   }
   class CUDAEnvironmentDirectedGraphBuffers {
       struct Buffer {
           enum Ready { None = 0, Host = 1, Device = 2, Both = 3};
           size_t element_size;
           void *d_ptr = nullptr;
           void* d_ptr_swap = nullptr;
           void *h_ptr = nullptr;
           mutable Ready ready = None;
           void swap() { std::swap(d_ptr, d_ptr_swap); }
           void updateHostBuffer(size_type edge_count, cudaStream_t stream) const;
       };
       const EnvironmentDirectedGraphData &graph_description;
       std::map<std::string, Buffer> vertex_buffers;
       std::map<std::string, Buffer> edge_buffers;
       std::list<std::weak_ptr<detail::curve::HostCurve>> curve_instances;
       std::list<std::weak_ptr<detail::curve::CurveRTCHost>> rtc_curve_instances;
   #ifdef FLAMEGPU_VISUALISATION
       mutable std::weak_ptr<visualiser::ModelVisData> visualisation;
   #endif
       size_type vertex_count;
       size_type edge_count;
       bool requires_rebuild;
       uint64_t *d_keys = nullptr, *d_keys_swap = nullptr;
       uint32_t *d_vals = nullptr, *d_vals_swap = nullptr;
       // CSR/VBM (edgesLeaving())
       unsigned int *d_pbm = nullptr, *d_pbm_swap = nullptr;
       // CSC/invertedVBM (edgesJoining()), shares d_pbm_swap
       unsigned int *d_ipbm = nullptr;
       // Copy of the vals list from constructing ipbm, required to lookup edges
       unsigned int *d_ipbm_edges = nullptr;
       // Vertex ID -> index map, ?? has been reserved, otherwise any ID is valid
       // However, the ID->index map does not utilise any compression, so non-contiguous ID ranges may lead to out of memory errors.
       unsigned int *d_vertex_index_map = nullptr;
   
       void allocateVertexBuffers(size_type count, cudaStream_t stream);
       void allocateEdgeBuffers(size_type count);
       void deallocateVertexBuffers();
       void deallocateEdgeBuffers();
       /*
        * Reset the internal vertex ID range tracking variables as though no vertices have been assigned IDs
        */
       void resetVertexIDBounds();
       unsigned int vertex_id_min = std::numeric_limits<unsigned int>::max();
       unsigned int vertex_id_max = std::numeric_limits<unsigned int>::min();
       std::map<id_t, unsigned int> h_vertex_index_map;
       util::PairMap<id_t, id_t, unsigned int> h_edge_index_map;
   
    public:
       explicit CUDAEnvironmentDirectedGraphBuffers(const EnvironmentDirectedGraphData &description);
       ~CUDAEnvironmentDirectedGraphBuffers();
       void registerCurveInstance(const std::shared_ptr<detail::curve::HostCurve>& curve);
       void registerCurveInstance(const std::shared_ptr<detail::curve::CurveRTCHost>& curve);
       const EnvironmentDirectedGraphData& getDescription() const { return graph_description; }
       void setVertexCount(size_type count, cudaStream_t stream);
       void setEdgeCount(size_type count);
       size_type getVertexCount() const { return vertex_count; }
       size_type getEdgeCount() const { return edge_count; }
       size_type getReadyVertexCount() const { return static_cast<size_type>(h_vertex_index_map.size()); }
       size_type getReadyEdgeCount() const { return static_cast<size_type>(h_edge_index_map.size()); }
       unsigned int createIfNotExistVertex(id_t vertex_id, cudaStream_t stream);
       unsigned int createIfNotExistEdge(id_t source_vertex_id, id_t dest_vertex_id, cudaStream_t stream);
       id_t* getVertexIDBuffer(cudaStream_t stream);
       template<typename T>
       const T* getVertexPropertyBuffer(const std::string& property_name, size_type &N, cudaStream_t stream) const;
       template<typename T>
       T* getVertexPropertyBuffer(const std::string& property_name, size_type &N, cudaStream_t stream);
       template<typename T>
       const T *getEdgePropertyBuffer(const std::string &property_name, size_type &N, cudaStream_t stream) const;
       template<typename T>
       T* getEdgePropertyBuffer(const std::string& property_name, size_type &N, cudaStream_t stream);
   #ifdef SWIG
       template<typename T>
       std::vector<T> getVertexPropertyArray(const std::string& property_name, const unsigned int vertex_index, cudaStream_t stream) const;
       template<typename T>
       std::vector<T> getEdgePropertyArray(const std::string& property_name, const unsigned int edge_index, cudaStream_t stream) const;
   #endif
       void markForRebuild() { requires_rebuild = true; }
       void syncDevice_async(detail::CUDAScatter& scatter, unsigned int streamID, cudaStream_t stream);
       void setVertexID(unsigned int vertex_index, id_t vertex_id, cudaStream_t stream);
       unsigned int getVertexIndex(id_t vertex_id) const;
       void setEdgeSourceDestination(unsigned int edge_index, id_t src_vertex_id, id_t dest_vertex_id);
       void setEdgeSource(unsigned int edge_index, id_t src_vertex_id);
       void setEdgeDestination(unsigned int edge_index, id_t dest_vertex_id);
       unsigned int getEdgeIndex(id_t src_vertex_id, id_t dest_vertex_id) const;
       id_t getSourceVertexID(unsigned int edge_index, cudaStream_t stream) const;
       id_t getDestinationVertexID(unsigned int edge_index, cudaStream_t stream) const;
   #ifdef FLAMEGPU_VISUALISATION
       void setVisualisation(std::shared_ptr<visualiser::ModelVisData> &_visualisation) const {
           this->visualisation = _visualisation;
       }
   #endif
   };
   
   
   template<typename T>
   const T* CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer(const std::string& property_name, size_type &N, cudaStream_t stream) const {
       if (!vertex_count) {
           THROW exception::OutOfBoundsException("Vertex buffers not yet allocated, in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()");
       }
       const auto &vv = graph_description.vertexProperties.find(property_name);
       if (vv == graph_description.vertexProperties.end()) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' not found, in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()", property_name.c_str());
       } else if (vv->second.type != std::type_index(typeid(typename detail::type_decode<T>::type_t))) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' type mismatch '%s' != '%s', in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()",
           property_name.c_str(), vv->second.type.name(), std::type_index(typeid(typename detail::type_decode<T>::type_t)).name());
       } else if (N == 0) {
           N = vv->second.elements;
       } else if (vv->second.elements != N) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' length mismatch '%u' != '%u', in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()",
               property_name.c_str(), N, vv->second.elements);
       }
       auto& vb = vertex_buffers.at(property_name);
       vb.updateHostBuffer(vertex_count, stream);
       return static_cast<T*>(vb.h_ptr);
   }
   template<typename T>
   T* CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer(const std::string& property_name, size_type &N, cudaStream_t stream) {
       if (!vertex_count) {
           THROW exception::OutOfBoundsException("Vertex buffers not yet allocated, in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()");
       }
       const auto& vv = graph_description.vertexProperties.find(property_name);
       if (vv == graph_description.vertexProperties.end()) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' not found, in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()", property_name.c_str());
       } else if (vv->second.type != std::type_index(typeid(typename detail::type_decode<T>::type_t))) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' type mismatch '%s' != '%s', in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()",
               property_name.c_str(), vv->second.type.name(), std::type_index(typeid(typename detail::type_decode<T>::type_t)).name());
       } else if (N == 0) {
           N = vv->second.elements;
       } else if (vv->second.elements != N) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' length mismatch '%u' != '%u', in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyBuffer()",
               property_name.c_str(), N, vv->second.elements);
       }
       auto &vb = vertex_buffers.at(property_name);
       vb.updateHostBuffer(vertex_count, stream);
       vb.ready = Buffer::Host;
       return static_cast<T*>(vb.h_ptr);
   }
   template<typename T>
   const T* CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer(const std::string& property_name, size_type &N, cudaStream_t stream) const {
       if (!edge_count) {
           THROW exception::OutOfBoundsException("Edge buffers not yet allocated, in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()");
       }
       const auto& ev = graph_description.edgeProperties.find(property_name);
       if (ev == graph_description.edgeProperties.end()) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' not found, in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()", property_name.c_str());
       } else if (ev->second.type != std::type_index(typeid(typename detail::type_decode<T>::type_t))) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' type mismatch '%s' != '%s', in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()",
               property_name.c_str(), ev->second.type.name(), std::type_index(typeid(typename detail::type_decode<T>::type_t)).name());
       } else if (N == 0) {
           N = ev->second.elements;
       } else if (ev->second.elements != N) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' length mismatch '%u' != '%u', in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()",
               property_name.c_str(), N, ev->second.elements);
       }
       auto &eb = edge_buffers.at(property_name);
       eb.updateHostBuffer(edge_count, stream);
       return static_cast<T*>(eb.h_ptr);
   }
   template<typename T>
   T* CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer(const std::string& property_name, size_type &N, cudaStream_t stream) {
       if (!edge_count) {
           THROW exception::OutOfBoundsException("Edge buffers not yet allocated, in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()");
       }
       const auto& ev = graph_description.edgeProperties.find(property_name);
       if (ev == graph_description.edgeProperties.end()) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' not found, in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()", property_name.c_str());
       } else if (ev->second.type != std::type_index(typeid(typename detail::type_decode<T>::type_t))) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' type mismatch '%s' != '%s', in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()",
               property_name.c_str(), ev->second.type.name(), std::type_index(typeid(typename detail::type_decode<T>::type_t)).name());
       } else if (N == 0) {
           N = ev->second.elements;
       } else if (ev->second.elements != N) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' length mismatch '%u' != '%u', in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyBuffer()",
               property_name.c_str(), N, ev->second.elements);
       }
       auto &eb = edge_buffers.at(property_name);
       eb.updateHostBuffer(edge_count, stream);
       eb.ready = Buffer::Host;
       return static_cast<T*>(eb.h_ptr);
   }
   #ifdef SWIG
   template<typename T>
   std::vector <T> CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyArray(const std::string& property_name, const unsigned int vertex_index, cudaStream_t stream) const {
       if (!vertex_count) {
           THROW exception::OutOfBoundsException("Vertex buffers not yet allocated, in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyArray()");
       }
       const auto& vv = graph_description.vertexProperties.find(property_name);
       if (vv == graph_description.vertexProperties.end()) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' not found, in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyArray()", property_name.c_str());
       } else if (vv->second.type != std::type_index(typeid(typename detail::type_decode<T>::type_t))) {
           THROW exception::InvalidGraphProperty("Vertex property with name '%s' type mismatch '%s' != '%s', in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyArray()",
               property_name.c_str(), vv->second.type.name(), std::type_index(typeid(typename detail::type_decode<T>::type_t)).name());
       } else if (vertex_index >= vertex_count) {
           THROW exception::OutOfBoundsException("Vertex index %u is out of range %u, in CUDAEnvironmentDirectedGraphBuffers::getVertexPropertyArray()\n",
               vertex_index, vertex_count);
       }
       std::vector<T> rtn(vv->second.elements);
       auto& vb = vertex_buffers.at(property_name);
       vb.updateHostBuffer(vertex_count, stream);
       memcpy(rtn.data(), static_cast<T*>(vb.h_ptr) + vertex_index * vv->second.elements, vv->second.type_size * vv->second.elements);
       return rtn;
   }
   template<typename T>
   std::vector<T> CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyArray(const std::string& property_name, const unsigned int edge_index, cudaStream_t stream) const {
       if (!edge_count) {
           THROW exception::OutOfBoundsException("Edge buffers not yet allocated, in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyArray()");
       }
       const auto& ev = graph_description.edgeProperties.find(property_name);
       if (ev == graph_description.edgeProperties.end()) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' not found, in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyArray()", property_name.c_str());
       }  else if (ev->second.type != std::type_index(typeid(typename detail::type_decode<T>::type_t))) {
           THROW exception::InvalidGraphProperty("Edge property with name '%s' type mismatch '%s' != '%s', in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyArray()",
               property_name.c_str(), ev->second.type.name(), std::type_index(typeid(typename detail::type_decode<T>::type_t)).name());
       } else if (edge_index >= edge_count) {
           THROW exception::OutOfBoundsException("Edge index %u is out of range %u, in CUDAEnvironmentDirectedGraphBuffers::getEdgePropertyArray()\n",
               edge_index, edge_count);
       }
       std::vector<T> rtn(ev->second.elements);
       auto& eb = edge_buffers.at(property_name);
       eb.updateHostBuffer(edge_count, stream);
       memcpy(rtn.data(), static_cast<T*>(eb.h_ptr) + edge_index * ev->second.elements, ev->second.type_size * ev->second.elements);
       return rtn;
   }
   #endif
   
   }  // namespace detail
   }  // namespace flamegpu
   
   #endif  // INCLUDE_FLAMEGPU_SIMULATION_DETAIL_CUDAENVIRONMENTDIRECTEDGRAPHBUFFERS_CUH_