Existing directed graph tests still pass, iteration should work needs tests.

Robadob · Robadob · commit 1b09d4f4d043 · 2025-01-18T20:47:44.000Z
diff --git a/include/flamegpu/runtime/environment/HostEnvironmentDirectedGraph.cuh b/include/flamegpu/runtime/environment/HostEnvironmentDirectedGraph.cuh
@@ -212,7 +212,7 @@ class HostEnvironmentDirectedGraph {
         class Edge {
             std::shared_ptr<detail::CUDAEnvironmentDirectedGraphBuffers> directed_graph;
             const cudaStream_t stream;
-            id_t source_vertex_id, destination_vertex_id;
+            unsigned int edge_index;
             friend Edge EdgeMap::operator[](SrcDestPair);
             friend struct Iterator;
 
@@ -289,30 +289,21 @@ class HostEnvironmentDirectedGraph {
             Iterator(std::shared_ptr<detail::CUDAEnvironmentDirectedGraphBuffers> _directed_graph, const cudaStream_t _stream, difference_type _index)
                 : directed_graph(std::move(_directed_graph))
                 , stream(_stream)
-                , index(_index)
                 , edge(_directed_graph, _stream, _index) {}
             reference operator*() const { return edge; }
             pointer operator->() const { return &edge; }
-            Iterator& operator++() { index++; update_edge(); return *this; }
-            Iterator operator++(int) { Iterator tmp = *this; ++(*this); tmp.update_edge();  return tmp; }
+            Iterator& operator++() { edge.edge_index++; return *this; }
+            Iterator operator++(int) { Iterator tmp = *this; ++(*this);  return tmp; }
 
-            bool operator== (const Iterator& a, const Iterator& b) const { return a.index == b.index; }
-            bool operator!= (const Iterator& a, const Iterator& b) const { return a.index != b.index; }
+            bool operator== (const Iterator& other) const { return edge.edge_index == other.edge.edge_index; }
+            bool operator!= (const Iterator& other) const { return edge.edge_index != other.edge.edge_index; }
 
             Iterator begin() { return { directed_graph, stream, 0 }; }
             Iterator end() { return { directed_graph, stream, directed_graph->getEdgeCount() }; }
 
          private:
-            void update_edge() {
-                edge.source_vertex_id = directed_graph->getSourceVertexID(index, stream);
-                edge.destination_vertex_id = directed_graph->getDestinationVertexID(index, stream);
-                if (edge.source_vertex_id == ID_NOT_SET || edge.destination_vertex_id == ID_NOT_SET) {
-                    index = directed_graph->getEdgeCount();
-                }
-            }
             std::shared_ptr<detail::CUDAEnvironmentDirectedGraphBuffers> directed_graph;
             cudaStream_t stream;
-            difference_type index;
             mutable Edge edge;
         };
 
@@ -343,8 +334,6 @@ std::vector<T> HostEnvironmentDirectedGraph::VertexMap::Vertex::getPropertyArray
 }
 template<typename T>
 void HostEnvironmentDirectedGraph::EdgeMap::Edge::setPropertyArray(const std::string& property_name, const std::vector<T>& property_value) const {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     size_type n = property_value.size();
     T* val = directed_graph->getEdgePropertyBuffer<T>(property_name, n, stream);
     if (!property_value.size()) {
@@ -355,8 +344,6 @@ void HostEnvironmentDirectedGraph::EdgeMap::Edge::setPropertyArray(const std::st
 }
 template<typename T>
 std::vector<T> HostEnvironmentDirectedGraph::EdgeMap::Edge::getPropertyArray(const std::string& property_name) const {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     return directed_graph->getEdgePropertyArray<T>(property_name, edge_index, stream);
 }
 #endif
@@ -422,16 +409,12 @@ std::array<T, N> HostEnvironmentDirectedGraph::VertexMap::Vertex::getProperty(co
 
 template<typename T>
 void HostEnvironmentDirectedGraph::EdgeMap::Edge::setProperty(const std::string& property_name, const T property_value) {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     size_type element_ct = 1;
     T* val = directed_graph->getEdgePropertyBuffer<T>(property_name, element_ct, stream);
     val[edge_index] = property_value;
 }
 template<typename T, flamegpu::size_type N>
 void HostEnvironmentDirectedGraph::EdgeMap::Edge::setProperty(const std::string& property_name, const size_type element_index, const T property_value) {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     size_type element_ct = N;
     T* val = directed_graph->getEdgePropertyBuffer<T>(property_name, element_ct, stream);
     if (element_index >= element_ct) {
@@ -442,25 +425,19 @@ void HostEnvironmentDirectedGraph::EdgeMap::Edge::setProperty(const std::string&
 }
 template<typename T, flamegpu::size_type N>
 void HostEnvironmentDirectedGraph::EdgeMap::Edge::setProperty(const std::string& property_name, const std::array<T, N>& property_value) {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     size_type element_ct = N;
     T* val = directed_graph->getEdgePropertyBuffer<T>(property_name, element_ct, stream);
     std::array<T, N>* val2 = reinterpret_cast<std::array<T, N>*>(val);
     val2[edge_index] = property_value;
 }
 template<typename T>
 T HostEnvironmentDirectedGraph::EdgeMap::Edge::getProperty(const std::string& property_name) const {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     size_type element_ct = 1;
     const T* rtn = const_cast<const detail::CUDAEnvironmentDirectedGraphBuffers*>(directed_graph.get())->getEdgePropertyBuffer<T>(property_name, element_ct, stream);
     return rtn[edge_index];
 }
 template<typename T, flamegpu::size_type N>
 T HostEnvironmentDirectedGraph::EdgeMap::Edge::getProperty(const std::string& property_name, const size_type element_index) const {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     size_type element_ct = N;
     const T* rtn = const_cast<const detail::CUDAEnvironmentDirectedGraphBuffers*>(directed_graph.get())->getEdgePropertyBuffer<T>(property_name, element_ct, stream);
     if (element_index >= element_ct) {
@@ -471,8 +448,6 @@ T HostEnvironmentDirectedGraph::EdgeMap::Edge::getProperty(const std::string& pr
 }
 template<typename T, flamegpu::size_type N>
 std::array<T, N> HostEnvironmentDirectedGraph::EdgeMap::Edge::getProperty(const std::string& property_name) const {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     size_type element_ct = N;
     const T *rtn = const_cast<const detail::CUDAEnvironmentDirectedGraphBuffers*>(directed_graph.get())->getEdgePropertyBuffer<T>(property_name, element_ct, stream);
     const std::array<T, N>* rtn2 = reinterpret_cast<const std::array<T, N>*>(rtn);
diff --git a/include/flamegpu/simulation/detail/CUDAEnvironmentDirectedGraphBuffers.cuh b/include/flamegpu/simulation/detail/CUDAEnvironmentDirectedGraphBuffers.cuh
@@ -265,10 +265,30 @@ class CUDAEnvironmentDirectedGraphBuffers {
     * @param src_vertex_id The ID that has been assigned to the source vertex of the edge
     * @param dest_vertex_id The ID that has been assigned to the destination vertex of the edge
     *
-    * @throws exception::IDCollision If the ID is already assigned to a different vertex
+    * @throws exception::IDCollision If the ID source/dest pair is already assigned to a different edge
     */
     void setEdgeSourceDestination(unsigned int edge_index, id_t src_vertex_id, id_t dest_vertex_id);
     /**
+    * Updates the edge ID buffer
+    * Updates the internal host map of src:dest->index
+    *
+    * @param edge_index The index of the edge
+    * @param src_vertex_id The ID that has been assigned to the source vertex of the edge
+    *
+    * @throws exception::IDCollision If the ID source/dest pair is already assigned to a different edge
+    */
+    void setEdgeSource(unsigned int edge_index, id_t src_vertex_id);
+    /**
+    * Updates the edge ID buffer
+    * Updates the internal host map of src:dest->index
+    *
+    * @param edge_index The index of the edge
+    * @param dest_vertex_id The ID that has been assigned to the destination vertex of the edge
+    *
+    * @throws exception::IDCollision If the ID source/dest pair is already assigned to a different edge
+    */
+    void setEdgeDestination(unsigned int edge_index, id_t dest_vertex_id);
+    /**
     * Returns the index of the edge with the given source and destination vertices
     * @param src_vertex_id The ID that has been assigned to the source vertex of the edge
     * @param dest_vertex_id The ID that has been assigned to the destination vertex of the edge
diff --git a/src/flamegpu/runtime/environment/HostEnvironmentDirectedGraph.cu b/src/flamegpu/runtime/environment/HostEnvironmentDirectedGraph.cu
@@ -152,38 +152,24 @@ Edge EdgeMap::operator[](SrcDestPair source_dest_vertex_ids) {
 Edge::Edge(std::shared_ptr<detail::CUDAEnvironmentDirectedGraphBuffers> _directed_graph, const cudaStream_t _stream, id_t _source_vertex_id, id_t _dest_vertex_id)
     : directed_graph(std::move(_directed_graph))
     , stream(_stream)
-    , source_vertex_id(_source_vertex_id)
-    , destination_vertex_id(_dest_vertex_id) { }
+    , edge_index(directed_graph->getEdgeIndex(_source_vertex_id, _dest_vertex_id)) { }
 
-Edge::Edge(std::shared_ptr<detail::CUDAEnvironmentDirectedGraphBuffers> _directed_graph, const cudaStream_t _stream, unsigned int edge_index)
+Edge::Edge(std::shared_ptr<detail::CUDAEnvironmentDirectedGraphBuffers> _directed_graph, const cudaStream_t _stream, unsigned int _edge_index)
     : directed_graph(std::move(_directed_graph))
     , stream(_stream)
-    , source_vertex_id(_directed_graph->getSourceVertexID(edge_index, _stream))
-    , destination_vertex_id(_directed_graph->getDestinationVertexID(edge_index, _stream))
+    , edge_index(_edge_index)
     { }
 void Edge::setSourceVertexID(id_t _source_vertex_id) {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     // Update ID
-    directed_graph->setEdgeSourceDestination(edge_index, _source_vertex_id, destination_vertex_id);
-    // Update local copy of ID
-    source_vertex_id = _source_vertex_id;
+    directed_graph->setEdgeSource(edge_index, _source_vertex_id);
 }
 void Edge::setDestinationVertexID(id_t _dest_vertex_id) {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     // Update ID
-    directed_graph->setEdgeSourceDestination(edge_index, source_vertex_id, _dest_vertex_id);
-    // Update local copy of ID
-    destination_vertex_id = _dest_vertex_id;
+    directed_graph->setEdgeDestination(edge_index, _dest_vertex_id);
 }
 void Edge::setSourceDestinationVertexID(id_t _source_vertex_id, id_t _dest_vertex_id) {
-    // Get index
-    const unsigned int edge_index = directed_graph->getEdgeIndex(source_vertex_id, destination_vertex_id);
     // Update ID
     directed_graph->setEdgeSourceDestination(edge_index, _source_vertex_id, _dest_vertex_id);
-    // Update local copy of ID
-    destination_vertex_id = _dest_vertex_id;
 }
 id_t Edge::getSourceVertexID() const {
     return getProperty<id_t, 2>(GRAPH_SOURCE_DEST_VARIABLE_NAME, 1);
diff --git a/src/flamegpu/simulation/detail/CUDAEnvironmentDirectedGraphBuffers.cu b/src/flamegpu/simulation/detail/CUDAEnvironmentDirectedGraphBuffers.cu
@@ -411,15 +411,17 @@ void CUDAEnvironmentDirectedGraphBuffers::syncDevice_async(detail::CUDAScatter&
         }
     }
     if (requires_rebuild && vertex_count && edge_count) {
+        if (edge_count != h_edge_index_map.size()) {
+            THROW exception::IDNotSet("Unable to build graph, only %u/%u edges have been assigned both a source and destination, in CUDAEnvironmentDirectedGraphBuffers::syncDevice_async()", edge_count, static_cast<unsigned int>(h_edge_index_map.size()));
+        } else if (vertex_count != h_vertex_index_map.size()) {
+            THROW exception::IDNotSet("Unable to build graph, only %u/%u vertices have been assigned an ID, in CUDAEnvironmentDirectedGraphBuffers::syncDevice_async()", vertex_count, static_cast<unsigned int>(h_vertex_index_map.size()));
+        }
         // Construct the vertex ID : index map
         {
             if (vertex_id_min == std::numeric_limits<unsigned int>::max() || vertex_id_max == std::numeric_limits<unsigned int>::min()) {
                 THROW flamegpu::exception::IDOutOfBounds("No IDs have been set, in CUDAEnvironmentDirectedGraphBuffers::syncDevice_async()");
             }
             const unsigned int ID_RANGE = 1 + vertex_id_max - vertex_id_min;
-            if (ID_RANGE < vertex_count) {
-                THROW flamegpu::exception::IDNotSet("Not all vertices have been assigned a unique ID, in CUDAEnvironmentDirectedGraphBuffers::syncDevice_async()");
-            }
             if (d_vertex_index_map) {
                 gpuErrchk(flamegpu::detail::cuda::cudaFree(d_vertex_index_map));
             }
@@ -688,6 +690,80 @@ void CUDAEnvironmentDirectedGraphBuffers::setEdgeSourceDestination(unsigned int
     // Require rebuild before use
     markForRebuild();
 }
+void CUDAEnvironmentDirectedGraphBuffers::setEdgeSource(unsigned int edge_index, id_t src_vertex_id) {
+    if (edge_index >= edge_count) {
+        THROW exception::OutOfBoundsException("Edge index exceeds bounds %u >= %u, "
+            "in CUDAEnvironmentDirectedGraphBuffers::setEdgeSource()\n", edge_index, edge_count);
+    } else if (src_vertex_id == ID_NOT_SET) {
+        THROW exception::IDOutOfBounds("Source vertex ID of %u is not valid, "
+            "in CUDAEnvironmentDirectedGraphBuffers::setEdgeSource()\n", ID_NOT_SET);
+    }
+    // Purge old edge src/dest from host map
+    auto& eb = edge_buffers.at(GRAPH_SOURCE_DEST_VARIABLE_NAME);
+    // Don't need to update buffer, src_dest is not stored as ID on device
+    id_t& edge_dest = static_cast<id_t*>(eb.h_ptr)[edge_index * 2 + 0];
+    id_t& edge_src = static_cast<id_t*>(eb.h_ptr)[edge_index * 2 + 1];
+
+    // Remove old edge from src map if it's complete
+    if (edge_src != ID_NOT_SET && edge_dest != ID_NOT_SET) {
+        h_edge_index_map.erase({edge_src, edge_dest});
+    }
+
+    // Update edge's src dest in buffer
+    edge_src = src_vertex_id;
+    eb.ready = Buffer::Host;
+
+    // Add new edge ID to host map if it's complete
+    if (edge_src != ID_NOT_SET && edge_dest != ID_NOT_SET) {
+        // validate it's not already in use
+        const auto find = h_edge_index_map.find({ edge_src, edge_dest });
+        if (find != h_edge_index_map.end()) {
+            THROW exception::IDCollision("Edge collision, an edge has already been assigned source %u dest %u at index %u, "
+                "in CUDAEnvironmentDirectedGraphBuffers::setEdgeSource()\n", src_vertex_id, edge_dest, find->second);
+        }
+        h_edge_index_map.emplace(std::pair{src_vertex_id, edge_dest }, edge_index);
+    }
+
+    // Require rebuild before use
+    markForRebuild();
+}
+void CUDAEnvironmentDirectedGraphBuffers::setEdgeDestination(unsigned int edge_index, id_t dest_vertex_id) {
+    if (edge_index >= edge_count) {
+        THROW exception::OutOfBoundsException("Edge index exceeds bounds %u >= %u, "
+            "in CUDAEnvironmentDirectedGraphBuffers::setEdgeDestination()\n", edge_index, edge_count);
+    } else if (dest_vertex_id == ID_NOT_SET) {
+        THROW exception::IDOutOfBounds("Destination vertex ID of %u is not valid, "
+            "in CUDAEnvironmentDirectedGraphBuffers::setEdgeDestination()\n", ID_NOT_SET);
+    }
+    // Purge old edge src/dest from host map
+    auto& eb = edge_buffers.at(GRAPH_SOURCE_DEST_VARIABLE_NAME);
+    // Don't need to update buffer, src_dest is not stored as ID on device
+    id_t& edge_dest = static_cast<id_t*>(eb.h_ptr)[edge_index * 2 + 0];
+    id_t& edge_src = static_cast<id_t*>(eb.h_ptr)[edge_index * 2 + 1];
+
+    // Update edge's src dest in buffer
+    if (edge_src != ID_NOT_SET && edge_dest != ID_NOT_SET) {
+        h_edge_index_map.erase({edge_src, edge_dest});
+    }
+
+    // Update edge's src dest in buffer
+    edge_dest = dest_vertex_id;
+    eb.ready = Buffer::Host;
+
+    // Add new edge ID to host map if it's complete
+    if (edge_src != ID_NOT_SET && edge_dest != ID_NOT_SET) {
+        // validate it's not already in use
+        const auto find = h_edge_index_map.find({ edge_src, edge_dest });
+        if (find != h_edge_index_map.end()) {
+            THROW exception::IDCollision("Edge collision, an edge has already been assigned source %u dest %u at index %u, "
+                "in CUDAEnvironmentDirectedGraphBuffers::setEdgeDestination()\n", edge_src, edge_dest, find->second);
+        }
+        h_edge_index_map.emplace(std::pair{ edge_src, edge_dest }, edge_index);
+    }
+
+    // Require rebuild before use
+    markForRebuild();
+}
 unsigned int CUDAEnvironmentDirectedGraphBuffers::getEdgeIndex(id_t src_vertex_id, id_t dest_vertex_id) const {
     const auto find = h_edge_index_map.find({src_vertex_id, dest_vertex_id});
     if (find == h_edge_index_map.end()) {
