Tests added, to check correctness, made with pytest

Author: KrishSingaria

.gitignore

@@ -7,4 +7,6 @@ benchmark/dataset
 *.gl
 *.zip
 *.npz
-benchmark/*.csv
+benchmark/*.csv
+
+*_pycache__/

dummy.csv

@@ -108,10 +108,10 @@ class LRUTable
 public:
     LRUTable(int64_t maxCapacity, std::function<std::span<float>(int64_t)> weightFunc) : MAXCAPACITY(maxCapacity), getWeights(weightFunc) {}
 
-    const AliasTable& get_alias_table(int64_t nodeId);
+    const AliasTable& get_alias_table(int64_t nodeId,int64_t nodeDegree);
 };
 
-inline const AliasTable& LRUTable::get_alias_table(int64_t nodeID){
+inline const AliasTable& LRUTable::get_alias_table(int64_t nodeID, int64_t nodeDegree){
     auto it = isNodePresent.find(nodeID);
     if(it != isNodePresent.end()){ // cache HIT
 
@@ -125,6 +125,10 @@ inline const AliasTable& LRUTable::get_alias_table(int64_t nodeID){
     // Weights
     std::span<float> span_w = getWeights(nodeID);
     std::vector<float> weights(span_w.begin(),span_w.end());
+
+    if(weights.empty()){
+        weights = std::vector<float>(nodeDegree,1.0);
+    }
 
     AliasTable newTable(weights);
 

generateGraph.cpp

@@ -1,6 +1,7 @@
 #ifndef CSR_H
 #define CSR_H
 #include "MemoryMap.hpp"
+#include "csrFilegen.hpp"
 #include <span>
 #include <cstddef>
 
@@ -41,7 +42,7 @@ class CSR{
     int64_t* get_colPtr(){
         return colPtr;
     }
-    float* get_weights(){
+    float* get_weightsPtr(){
         return weightPtr;
     }
     int64_t  get_num_nodes(){
@@ -75,8 +76,8 @@ inline CSR::CSR(const char* graphPath){
 
     if(has_weights){
         char* base = static_cast<char*>(this->graphMap->get_data()); // 1byte shifts
-
-        this->weightPtr = reinterpret_cast<float*>(base + header.offset_col + this->sizeofcolPtr);
+        uint64_t offset_weights = align64(header.offset_col + this->sizeofcolPtr);
+        this->weightPtr = reinterpret_cast<float*>(base + offset_weights);
     }else this->weightPtr = nullptr;  
 }
 
@@ -89,23 +90,30 @@ inline CSR::~CSR(){
 }
 
 inline int64_t CSR::get_degree(int64_t nodeId){
-    // return degree of nodeId, how many conections it have 
+    // return degree of nodeId, how many conections it have
+    if(nodeId >= num_nodes) return 0;
     return this->nnzRow[nodeId+1] - this->nnzRow[nodeId];
 }
 inline std::span<int64_t> CSR::get_edges(int64_t nodeId){
     // return the edges of nodeId
+    if(nodeId>= num_nodes){
+        throw std::runtime_error("NodeId is greater than number of nodes.");
+    }
     int64_t* p =&this->colPtr[this->nnzRow[nodeId]];
     int64_t  d = this->get_degree(nodeId);
     return std::span<int64_t>(p,d);
 }
 
 inline std::span<float> CSR::get_weights(int64_t nodeId){
     // return the weights of nodeId, only valid if has_weights is true
+    if(nodeId>= num_nodes){
+        throw std::runtime_error("NodeId is greater than number of nodes.");
+    }
     if(!has_weights){
         throw std::runtime_error("Graph does not have weights");
     }
     float* p =&this->weightPtr[this->nnzRow[nodeId]];
-    int64_t  d = this->get_degree(nodeId);
+    int64_t d = this->get_degree(nodeId);
     return std::span<float>(p,d);
 }
 

main.cpp

@@ -86,6 +86,7 @@ inline void Graphzero::ReservoirSampling(int64_t nodeId, int k, int64_t* result)
         for(int i = 0; i < deg; i++){
             result[i] = neighbours[i];
         }
+        return;
     }
 
     // selection k neighbours, first k elements
@@ -143,10 +144,7 @@ inline void Graphzero::randomWalk(int64_t start_node, int64_t length, float p, f
     auto weightFunc = [this](int64_t nodeID){
         if(this->has_weights) return this->storage->get_weights(nodeID);
         else{
-            int64_t nodeDegree = this->storage->get_degree(nodeID);
-            std::vector<float> weights(nodeDegree);
-            for (float& w : weights) w = RNG.rand();
-            return std::span<float>(weights);
+            return std::span<float>(); // lrutable detect if empty
         }
     };
 
@@ -156,12 +154,15 @@ inline void Graphzero::randomWalk(int64_t start_node, int64_t length, float p, f
 
     walk[0] = start_node;
 
-    for (int64_t i = 1; i < length; i++)
+    for (int64_t i = 1; i <= length; i++)
     {
         int64_t degree = storage->get_degree(curr);
-        if (degree == 0) break; // Dead end
+        if (degree == 0){ // Dead end
+            walk[i] = curr;
+            continue;
+        }; 
 
-        auto table = lruCache.get_alias_table(curr);
+        auto table = lruCache.get_alias_table(curr,this->storage->get_degree(curr));
         if(i == 1){
             next = storage->get_edges(curr)[table.sample()];
         }else {
@@ -175,7 +176,7 @@ inline void Graphzero::randomWalk(int64_t start_node, int64_t length, float p, f
 
 //keep p = 1.0f and q = 1.0f for default values.
 inline std::vector<int64_t>* Graphzero::batchRandomWalk(const std::vector<int64_t>& startNodes, int64_t walkLength, float p, float q){
-    std::vector<int64_t>* results = new std::vector<int64_t>(walkLength*startNodes.size());
+    std::vector<int64_t>* results = new std::vector<int64_t>((walkLength+1)*startNodes.size());
 
     // set only for random walks 
     storage->set_access_pattern(true);
@@ -184,7 +185,7 @@ inline std::vector<int64_t>* Graphzero::batchRandomWalk(const std::vector<int64_
     for(signed long long i = 0; i < startNodes.size(); i++){
 
         // thread safe
-        int64_t offset = i*walkLength;
+        int64_t offset = i*(walkLength+1);
 
         randomWalk(startNodes[i],walkLength,p,q, results->data() + offset);
     }
@@ -195,15 +196,15 @@ inline std::vector<int64_t>* Graphzero::batchRandomWalk(const std::vector<int64_
 }
 
 inline std::vector<int64_t>* Graphzero::batchRandomUniformWalk(const std::vector<int64_t>& startNodes, int64_t walkLength){
-    std::vector<int64_t>* results = new std::vector<int64_t>(walkLength*startNodes.size());
+    std::vector<int64_t>* results = new std::vector<int64_t>((walkLength + 1)*startNodes.size());
 
     // set only for random walks 
     storage->set_access_pattern(true);
 
     #pragma omp parallel for
     for(signed long long i = 0; i < startNodes.size(); i++){
         // walking here 
-        int64_t offset = (int64_t)(i*walkLength);
+        int64_t offset = (int64_t)(i*(walkLength+1));
         int64_t curr = startNodes[i], next;
         (*results)[offset] = curr;
         for(int64_t j = 1; j < walkLength; ++j){
@@ -237,7 +238,7 @@ inline std::vector<int64_t>* Graphzero::batchRandomFanout(const std::vector<int6
 
         // thread safe write into results
         int64_t offset = i * K;
-        ReservoirSampling(startNodes[i], (int)K, results->data() + offset);
+        this->ReservoirSampling(startNodes[i], (int)K, results->data() + offset);
     }
 
     // reset

src/AliasTable.hpp

@@ -47,8 +47,7 @@ R"doc(Get the degree of a node.
             // the Graph object alive as the owner.
             return nb::ndarray<nb::numpy, int64_t, nb::shape<1>>(
                 const_cast<int64_t*>(edges.data()), // pointer to data
-                { edges.size() },                 // shape
-                nb::cast(self)                    // owner: keep Graph instance alive
+                { edges.size() }                    // shape
             );
         },
             nb::keep_alive<0,1>(),
@@ -68,8 +67,7 @@ R"doc(Returns the neighbours of a node.
             // the Graph object alive as the owner.
             return nb::ndarray<nb::numpy, float, nb::shape<1>>(
                 const_cast<float*>(weights.data()), // pointer to data
-                { weights.size() },                 // shape
-                nb::cast(self)                    // owner: keep Graph instance alive
+                { weights.size() }                  // shape
             );
         },
             nb::keep_alive<0,1>(),
@@ -93,7 +91,7 @@ R"doc(Returns the edge weight of neighbours of a node.
 
             return nb::ndarray<nb::numpy, int64_t, nb::shape<2>>(
                 walkData->data(),
-                {startNodes.size(),static_cast<size_t>(walkLength) },
+                {startNodes.size(),static_cast<size_t>(walkLength + 1) },
                 owner
             );
         },
@@ -124,7 +122,7 @@ R"doc(Performs 2nd-order random walks (Node2Vec style).
 
             return nb::ndarray<nb::numpy, int64_t, nb::shape<2>>(
                 walkData->data(),
-                {startNodes.size(),static_cast<size_t>(walkLength)},
+                {startNodes.size(),static_cast<size_t>(walkLength + 1)},
                 owner
             );
         },
@@ -170,7 +168,7 @@ R"doc(Performs uniform random fanout sampling.
         )
 
         .def("sample_neighbours", [](Graphzero &self, int64_t startNode, int64_t K) {
-            std::vector<int64_t>* walkData = new std::vector<int64_t>(K);
+            std::vector<int64_t>* walkData = new std::vector<int64_t>((std::min)(K,self.get_storage()->get_degree(startNode)));
             self.ReservoirSampling(startNode, K, walkData->data());
 
             nb::capsule owner(walkData, [](void* p) noexcept {