windows support complete

Author: KrishSingaria

CMakeLists.txt

@@ -14,6 +14,7 @@ nanobind_add_module(graphzero
 # 3. Compiler Settings
 target_include_directories(graphzero PRIVATE src)
 target_compile_features(graphzero PUBLIC cxx_std_20)
+target_compile_definitions(graphzero PRIVATE NOMINMAX)
 
 # Link OpenMP if found (Essential for your Day 20 speedup)
 if(OpenMP_CXX_FOUND)

dummy.csv

@@ -0,0 +1,5 @@
+src,dst
+0,1
+1,2
+2,0
+0,3

generateGraph.cpp

@@ -1,18 +1,18 @@
 #include "src/csrFilegen.hpp"
 
-// int main(int argc, char const *argv[])
-// {
-//     // generateLargeGraph(100000,0.05f,"graph-100T.gl");
-//     return 0;
-// }
+int main(int argc, char const *argv[])
+{
+    generateLargeGraph(100000,0.05f,"graph-100T.gl");
+    return 0;
+}
 
 // csv_to_gl
-int main(int argc, char** argv) {
-    if (argc < 3) {
-        std::cerr << "Usage: ./converter <input.csv> <output.gl> [directed=0]" << std::endl;
-        return 1;
-    }
-    bool directed = (argc > 3 && std::string(argv[3]) == "1");
-    convert_csv(argv[1], argv[2], directed);
-    return 0;
-}
+// int main(int argc, char** argv) {
+//     if (argc < 3) {
+//         std::cerr << "Usage: ./converter <input.csv> <output.gl> [directed=0]" << std::endl;
+//         return 1;
+//     }
+//     bool directed = (argc > 3 && std::string(argv[3]) == "1");
+//     convert_csv(argv[1], argv[2], directed);
+//     return 0;
+// }

src/CSR.hpp

@@ -72,13 +72,15 @@ inline std::span<size_t> CSR::get_edges(size_t nodeId){
 }
 
 inline void CSR::set_access_pattern(bool isRandom){
+    #ifndef _WIN32 
     if(isRandom){
         madvise(this->nnzRow,this->sizeofnnzRow,MADV_RANDOM);
         madvise(this->colPtr,this->sizeofcolPtr,MADV_RANDOM);
     }else{
         madvise(this->nnzRow,this->sizeofcolPtr,MADV_SEQUENTIAL);
         madvise(this->colPtr,this->sizeofcolPtr,MADV_SEQUENTIAL);
     }
+    #endif // linux
 }
 // accessors
 

src/Graphzero.hpp

@@ -108,7 +108,7 @@ inline bool Graphzero::isNeighbor(size_t u, size_t v){
 // return next step in node2vec algo
 inline size_t Graphzero::node2vec_step(size_t curr, size_t prev, float p, float q, const AliasTable& table){
     // Rejection sampling 
-    float maxBias = std::max({1.0f,1.0f/p,1.0f/q});
+    float maxBias = (std::max)({1.0f,1.0f/p,1.0f/q}); // for windows max
 
     while (true)
     {
@@ -162,16 +162,20 @@ inline std::vector<size_t> Graphzero::randomWalk(size_t start_node, size_t lengt
 
 //keep p = 1.0f and q = 1.0f for default values.
 inline std::vector<size_t> Graphzero::batchRandomWalk(const std::vector<size_t>& startNodes, size_t walkLength, float p, float q){
-    std::vector<size_t> results;
-    results.reserve(walkLength*startNodes.size());
+    std::vector<size_t> results(walkLength*startNodes.size());
 
     // set only for random walks 
     storage->set_access_pattern(true);
 
     #pragma omp parallel for
-    for(size_t startNode: startNodes){
-        std::vector<size_t> walk = randomWalk(startNode,walkLength,p,q);
-        results.insert(results.end(),walk.begin(),walk.end()); // extend the results 
+    for(signed long long i = 0; i < startNodes.size(); i++){
+        std::vector<size_t> walk = randomWalk(startNodes[i],walkLength,p,q);
+        
+        // thread safe
+        size_t offset = i*walkLength;
+        for(int j = 0; j < walk.size(); j++){
+            results[j+offset] = walk[j];
+        }
     }
 
     // reset
@@ -180,20 +184,57 @@ inline std::vector<size_t> Graphzero::batchRandomWalk(const std::vector<size_t>&
 }
 
 inline std::vector<size_t> Graphzero::batchRandomUniformWalk(const std::vector<size_t>& startNodes, size_t walkLength){
-    std::vector<size_t> results;
-    results.reserve(walkLength*startNodes.size());
+    std::vector<size_t> results(walkLength*startNodes.size());
 
     // set only for random walks 
     storage->set_access_pattern(true);
 
     #pragma omp parallel for
-    for(size_t startNode: startNodes){
-        std::vector<size_t> walk = ReservoirSampling(startNode,walkLength);
-        results.insert(results.end(),walk.begin(),walk.end()); // extend the results 
+    for(signed long long i = 0; i < startNodes.size(); i++){
+        // walking here 
+        size_t offset = i*walkLength;
+        size_t curr = startNodes[i], next;
+        results[offset] = curr;
+        for(size_t j = 1; j < walkLength; ++j){
+            auto edges = storage->get_edges(curr);
+
+            if(edges.size() == 0){
+                results[offset+j] = curr;
+                continue;
+            }
+
+            next = edges[RNG.rand_int(0,edges.size()-1)];
+            results[offset + j] = next;
+            curr = next;
+        }   
     }
 
     // reset
     storage->set_access_pattern(false);
     return results;
 }
+
+// not walk but sampling 
+// inline std::vector<size_t> Graphzero::batchRandomUniformWalk(const std::vector<size_t>& startNodes, size_t walkLength){
+//     std::vector<size_t> results;
+//     results.reserve(walkLength*startNodes.size());
+    
+//     // set only for random walks 
+//     storage->set_access_pattern(true);
+
+//     #pragma omp parallel for
+//     for(size_t i = 0; i < num_nodes; i++){
+//         std::vector<size_t> walk = ReservoirSampling(startNode,walkLength);
+        
+//         // thread safe
+//         size_t offset = i*walkLength;
+//         for(int j = 0; j < walk.size(); j++){
+//             results[j+offset] = walk[j];
+//         }
+//     }
+
+//     // reset
+//     storage->set_access_pattern(false);
+//     return results;
+// }
 #endif

src/MemoryMap.hpp

@@ -2,11 +2,17 @@
 #define MEMORYMAP_H
 #include <string>
 #include <cstddef>
+#include <stdexcept>
+#include <cstdint>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
 #include <fcntl.h>
-#include <unistd.h>
 #include <sys/stat.h>
+#include <unistd.h>
 #include <sys/mman.h>
-#include <stdexcept>
+#endif
 
 // only here
 const uint64_t MAGIC_NUM = 8388354976772092519; // 'graphlit' converted in size_t
@@ -26,9 +32,12 @@ struct GraphHeader {
 class MemoryMap
 {
 private:
+    #ifndef _WIN32
     int fd; // file descriptor
-    size_t length;
     struct stat st;
+    #endif
+
+    size_t length;
     void* mappedptr;
 public:
     // constructor accquires, no flags currently 
@@ -43,7 +52,36 @@ class MemoryMap
 
 inline MemoryMap::MemoryMap(const char* path){
     // acquires resource/bin file on the Path given
+    #ifdef _WIN32
+    HANDLE hFile = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if(hFile == INVALID_HANDLE_VALUE) { 
+        CloseHandle(hFile);
+        throw std::runtime_error("File open failed"); 
+    }
+    
+    LARGE_INTEGER fsize;
+    if((GetFileSizeEx(hFile,&fsize)) == 0){
+        CloseHandle(hFile);
+        throw std::runtime_error("can not get file size ");
+    }
+    length = fsize.QuadPart;
 
+    HANDLE hMap = CreateFileMappingA(hFile,NULL,PAGE_READONLY, 0,0,NULL);
+    if(hMap == NULL) { 
+        CloseHandle(hMap);
+        CloseHandle(hFile);
+        throw std:: runtime_error("File mapping failed"); 
+    }
+
+    mappedptr = MapViewOfFile(hMap,FILE_MAP_READ, 0,0,0);
+    if(mappedptr == NULL) {
+        throw std::runtime_error("mappedptr is NULL, could not map");
+    }
+
+    CloseHandle(hMap);
+    CloseHandle(hFile);
+
+    #else // linux
     if((fd = open(path,O_RDONLY)) == -1){
         throw std::runtime_error("File open failed");
     }
@@ -61,21 +99,30 @@ inline MemoryMap::MemoryMap(const char* path){
 
     // memory advise to use huge pages
     madvise(mappedptr,length, MADV_HUGEPAGE);
+
+    #endif 
+
 }
 
 inline MemoryMap::~MemoryMap(){
     // release resource, destory itself
-
+    #ifdef _WIN32
+    if (mappedptr != nullptr) {
+        UnmapViewOfFile(mappedptr);
+        mappedptr = nullptr;
+    }
+    #else// linux
     if(mappedptr != MAP_FAILED && mappedptr != nullptr){
         munmap(mappedptr,length);
     }
 
     if(fd != -1){
         close(fd);
     }
-
     fd = -1;
+    
     length = 0;
+    #endif 
 }
 inline void* MemoryMap::get_data(){
     // get data pointer