compile

csrc/cuda/grid_cuda.cu

@@ -11,7 +11,7 @@ template <typename scalar_t>
 __global__ void grid_kernel(const scalar_t *pos, const scalar_t *size,
                             const scalar_t *start, const scalar_t *end,
                             int64_t *out, int64_t D, int64_t numel) {
-  const size_t thread_idx = blockIdx.x * blockDim.x + threadIdx.x;
+  const int64_t thread_idx = blockIdx.x * blockDim.x + threadIdx.x;
 
   if (thread_idx < numel) {
     int64_t c = 0, k = 1;

csrc/cuda/radius_cuda.cu

@@ -64,8 +64,8 @@ torch::Tensor radius_cuda(torch::Tensor x, torch::Tensor y, torch::Tensor ptr_x,
     radius_kernel<scalar_t><<<ptr_x.size(0) - 1, THREADS, 0, stream>>>(
         x.data_ptr<scalar_t>(), y.data_ptr<scalar_t>(),
         ptr_x.data_ptr<int64_t>(), ptr_y.data_ptr<int64_t>(),
-        row.data_ptr<int64_t>(), col.data_ptr<int64_t>(), radius,
-        max_num_neighbors, x.size(1));
+        row.data_ptr<int64_t>(), col.data_ptr<int64_t>(), r, max_num_neighbors,
+        x.size(1));
   });
 
   auto mask = row != -1;

csrc/cuda/rw_cuda.cu

@@ -23,7 +23,7 @@ __global__ void uniform_random_walk_kernel(const int64_t *rowptr,
       cur = out[i];
       row_start = rowptr[cur], row_end = rowptr[cur + 1];
 
-      out[l * numel + n] =
+      out[l * numel + thread_idx] =
           col[row_start + int64_t(rand[i] * (row_end - row_start))];
     }
   }

torch_cluster/__init__.py

@@ -23,7 +23,7 @@ except OSError as e:
     raise OSError(e)
 
 if torch.version.cuda is not None:  # pragma: no cover
-    cuda_version = torch.ops.torch_sparse.cuda_version()
+    cuda_version = torch.ops.torch_cluster.cuda_version()
 
     if cuda_version == -1:
         major = minor = 0