Dev cuda

.gitignore

@@ -2,3 +2,7 @@
 .Rhistory
 .RData
 inst/doc
+.r-lib
+.ci
+ci_artifacts
+bin

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "bench/nvbench"]
+	path = bench/nvbench
+	url = https://github.com/NVIDIA/nvbench.git
+[submodule "thirdparty/Catch2"]
+	path = thirdparty/Catch2
+	url = https://github.com/catchorg/Catch2.git

CMakeLists.txt

@@ -0,0 +1,81 @@
+cmake_minimum_required(VERSION 3.20)
+cmake_policy(SET CMP0048 NEW)
+
+project(PROPR CXX)
+
+
+if ("${CMAKE_BUILD_TYPE}" STREQUAL "" OR ${CMAKE_BUILD_TYPE} STREQUAL "NOMODE")
+    message("WORKING ON NO MODE")
+elseif (${CMAKE_BUILD_TYPE} STREQUAL "RELEASE")
+    message("WORKING ON RELEASE MODE")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELEASE} -g")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_RELEASE} -g")
+elseif (${CMAKE_BUILD_TYPE} STREQUAL "DEBUG" OR ${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+    message("WORKING ON DEBUG MODE")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_DEBUG}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_DEBUG}")
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS}")
+else ()
+    message(FATAL_ERROR "Unrecognized build type")
+endif ()
+
+include(CheckLanguage)
+
+set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
+
+FIND_PACKAGE(R REQUIRED)
+if (${R_FOUND})
+    message("R              : FOUND")
+    list(APPEND LIBS "R")
+else ()
+    message("R              : NOT FOUND")
+endif ()
+
+check_language(CUDA)
+if (CMAKE_CUDA_COMPILER)
+    set(USE_CUDA ON)
+    message("Build CUDA Support")
+    set(PROPERTIES CUDA_ARCHITECTURES 90)
+    enable_language(CUDA)
+    include_directories(${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
+    set(USE_CUDA ON)
+    set(CMAKE_CUDA_STANDARD 17)
+    set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda --expt-relaxed-constexpr -lineinfo -O3 --use_fast_math --extra-device-vectorization")
+    message("CUDA           : FOUND")
+    find_package(CUDAToolkit REQUIRED)
+    execute_process(
+        COMMAND nvidia-smi --query-gpu=compute_cap --format=csv
+        COMMAND tail -n 1
+        COMMAND tr -d .
+        OUTPUT_VARIABLE NV_CC
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    message("Detected Compute Capability : " ${NV_CC})
+    set(PROPERTIES CUDA_ARCHITECTURES ${NV_CC})
+    set(CMAKE_CUDA_ARCHITECTURES ${NV_CC})
+else ()
+    message(FATAL_ERROR "CUDA           : NOT FOUND")
+endif ()
+
+if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    set(CMAKE_INSTALL_PREFIX "/usr")
+endif ()
+message("Install Prefix : " ${CMAKE_INSTALL_PREFIX})
+include_directories(${CMAKE_SOURCE_DIR}/inst/include)
+
+# set(CUTLASS_NVCC_ARCHS "90")
+# add_subdirectory(${CMAKE_SOURCE_DIR}/thirdparty/cutlass)
+# include_directories(${CMAKE_SOURCE_DIR}/thirdparty/cutlass/include/)
+
+option(PROPR_BUILD_TESTS "Option to enable building tests" OFF)
+
+add_subdirectory(src)
+message("Install Path   : ${CMAKE_INSTALL_PREFIX}")
+message("PROPR Tests    : ${PROPR_BUILD_TESTS}")
+
+install(DIRECTORY inst/include DESTINATION ${CMAKE_INSTALL_PREFIX}/PROPR
+        FILES_MATCHING
+            PATTERN "*.hpp"
+            PATTERN "*.h"
+            PATTERN "*.cuh")

DESCRIPTION

@@ -34,7 +34,7 @@ Imports:
     corpcor,
     ppcor,
     Rcpp,
-    stats
+    stats,
 Suggests:
     ALDEx2,
     fastcluster,
@@ -43,7 +43,8 @@ Suggests:
     parallel,
     rmarkdown,
     testthat (>= 3.0.0),
-    vegan
+    vegan,
+    nvtxR
 LinkingTo:
     Rcpp
 Config/testthat/edition: 3

OLDCMakeLists.txt

@@ -0,0 +1,122 @@
+cmake_minimum_required(VERSION 3.15)
+
+set(CMAKE_MODULE_PATH /home/zalbanob/propr/cmake)
+set(RCPP_INCLUDE_DIRS /home/zalbanob/R/x86_64-pc-linux-gnu-library/4.5/Rcpp/include)
+set(RCPP_LIB_PATH /home/zalbanob/R/x86_64-pc-linux-gnu-library/4.5/Rcpp/libs)
+
+set(CMAKE_CUDA_ARCHITECTURES 80 90)
+set(CUDACXX "/usr/local/cuda/bin/nvcc" CACHE FILEPATH "Path to nvcc compiler")
+project(propr LANGUAGES CXX CUDA)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+find_package(R REQUIRED)
+execute_process(
+        COMMAND "${R_BINARY}" -e "cat(Rcpp:::CxxFlags())"
+        OUTPUT_VARIABLE RCPP_CXX_FLAGS_OUTPUT
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+string(REPLACE "-I" "" RCPP_INCLUDE_DIRS_RAW "${RCPP_CXX_FLAGS_OUTPUT}")
+string(REPLACE " " ";" RCPP_INCLUDE_DIRS "${RCPP_INCLUDE_DIRS_RAW}")
+execute_process(
+        COMMAND "${R_BINARY}" -e "cat(Rcpp:::LdFlags())"
+        OUTPUT_VARIABLE RCPP_LDFLAGS_OUTPUT
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+set(RCPP_LINK_DIRS "")
+set(RCPP_LIBRARIES_LIST "")
+string(REGEX MATCHALL "-L[^ ]+" RCPP_LIB_DIRS_MATCHES "${RCPP_LDFLAGS_OUTPUT}")
+foreach(MATCH ${RCPP_LIB_DIRS_MATCHES})
+    string(REPLACE "-L" "" LIB_DIR ${MATCH})
+    list(APPEND RCPP_LINK_DIRS ${LIB_DIR})
+endforeach()
+
+string(REGEX MATCHALL "-l[^ ]+" RCPP_LIB_NAMES_MATCHES "${RCPP_LDFLAGS_OUTPUT}")
+foreach(MATCH ${RCPP_LIB_NAMES_MATCHES})
+    string(REPLACE "-l" "" LIB_NAME ${MATCH})
+    list(APPEND RCPP_LIBRARIES_LIST ${LIB_NAME})
+endforeach()
+
+find_package(CUDAToolkit 11.0 REQUIRED)
+
+
+set(PROPR_LIB_SOURCES
+        src/kernels/cuda/lrm.cu
+        src/kernels/cuda/lrv.cu
+
+        src/dispatch/cpu/backend.cpp
+        src/dispatch/cpu/comparison.cpp
+        src/dispatch/cpu/ctzRcpp.cpp
+        src/dispatch/cpu/graflex.cpp
+        src/dispatch/cpu/lr2propr.cpp
+        src/dispatch/cpu/lrm.cpp
+        src/dispatch/cpu/lrv.cpp
+        src/dispatch/cpu/omega.cpp
+
+        src/RcppExports.cpp
+        inst/include/propr/context.h
+        inst/include/propr/interface/device_selector.hpp
+        src/dispatch/device_selector.cpp
+        src/interface/lrv.cpp
+        src/interface/lrm.cpp
+        src/dispatch/cpu/lrm.cpp
+        src/dispatch/cpu/backend.cpp
+        inst/include/propr/kernels/cpu/dispatch/backend.hpp
+        src/interface/backend.cpp
+        src/interface/comparison.cpp
+        src/interface/graflex.cpp
+        src/interface/lr2propr.cpp
+        src/interface/omega.cpp
+)
+
+set(PROPR_BENCHMARK_SOURCES bench/src/main_benchmark.cu )
+
+add_library(propr SHARED ${PROPR_LIB_SOURCES})
+
+target_compile_features(propr PUBLIC cxx_std_14)
+set_target_properties(propr PROPERTIES
+        CUDA_STANDARD 14
+        CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}"
+)
+
+# Specify include directories for the library.
+target_include_directories(propr PUBLIC
+        # R includes (from find_package(R))
+        ${R_INCLUDE_DIRS}
+        # Rcpp includes (parsed from Rcpp:::CxxFlags())
+        ${RCPP_INCLUDE_DIRS}
+        # CUDA Toolkit includes (from find_package(CUDAToolkit))
+        ${CUDAToolkit_INCLUDE_DIRS}
+        # Local project headers (e.g., src/include/interface, src/include/kernels etc.)
+        inst/include
+        # Prereq headers (if they are part of the main library)
+        # The original CMakeLists.txt had `include_directories(prereq)`.
+        ${CMAKE_CURRENT_SOURCE_DIR}/prereq
+)
+
+# Link libraries for the main shared library.
+target_link_libraries(propr PUBLIC
+        # R runtime libraries (from find_package(R))
+        ${R_LIBRARIES}
+        # Rcpp libraries (parsed from Rcpp:::LdFlags())
+        ${RCPP_LIBRARIES_LIST}
+        # CUDA runtime libraries (from find_package(CUDAToolkit))
+        ${CUDAToolkit_LIBRARIES}
+)
+
+target_link_directories(propr PUBLIC ${RCPP_LINK_DIRS})
+set_target_properties(propr PROPERTIES OUTPUT_NAME "propr" SUFFIX ".so")
+
+add_executable(propr_benchmark ${PROPR_BENCHMARK_SOURCES})
+target_link_libraries(propr_benchmark PRIVATE propr)
+
+target_include_directories(propr_benchmark PRIVATE inst/include)
+
+# Set compile features for benchmark.
+target_compile_features(propr_benchmark PUBLIC cxx_std_14)
+set_target_properties(propr_benchmark PROPERTIES
+        CUDA_STANDARD 14
+        CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}"
+)

R/1-propr.R

@@ -70,6 +70,7 @@ propr <- function(counts,
                   alpha = NA,
                   p = 0,
                   permutation_option = c("feature-wise", "sample-wise")) {
+  NVTX_PUSH("propr", 0)
   ##############################################################################
   ### CLEAN UP ARGS
   ##############################################################################
@@ -141,46 +142,57 @@ propr <- function(counts,
   lambda <- NULL
 
   if (metric == "rho") {
+    NVTX_PUSH("metric == rho", 0)
     mat <- lr2rho(lr)
-
+    NVTX_POP()
   } else if (metric == "phi") {
+    NVTX_PUSH("metric == phi", 0)
     mat <- lr2phi(lr)
-    if (symmetrize)
-      symRcpp(mat) # optionally force symmetry
-
+    if (symmetrize) symRcpp(mat) # optionally force symmetry
+    NVTX_POP()
   } else if (metric == "phs") {
+    NVTX_PUSH("metric == phs", 0)
     mat <- lr2phs(lr)
-
+    NVTX_POP()
   } else if (metric == "cor") {
+    NVTX_PUSH("metric == cor", 0)
     mat <- stats::cor(lr)
-
+    NVTX_POP()
   } else if (metric == "vlr") {
     mat <- lrv
 
   } else if (metric == "ppcor") {
     packageCheck("ppcor")
+    NVTX_PUSH("metric == ppcor", 0)
     mat <- ppcor::pcor(lr)$estimate
-
+    NVTX_POP()
   } else if (metric == "pcor") {
     packageCheck("corpcor")
+
+    NVTX_PUSH("metric == pcor")
     cov <- cov(lr)
     mat <- corpcor::cor2pcor(cov)
     class(mat) <- "matrix"
-
+    NVTX_POP()
   } else if (metric == "pcor.shrink") {
     packageCheck("corpcor")
+
+    NVTX_PUSH("metric == pcor.shrink", 0)
     cov <- corpcor::cov.shrink(lr)
     mat <- corpcor::cor2pcor(cov)
     mat <- matrix(mat, ncol=ncol(lr), nrow=ncol(lr))
     class(mat) <- "matrix"
     lambda <- attr(cov, "lambda")
+    NVTX_POP()
 
   } else if (metric == "pcor.bshrink") {
+    NVTX_PUSH("metric == pcor.bshrink", 0)
+
     with(pcor.bshrink(ct, outtype = ivar_pcor), {
       mat <<- matrix
       lambda <<- lambda
     })
-
+    NVTX_POP()
   } else {
     stop("Provided 'metric' not recognized.")
   }
@@ -232,6 +244,6 @@ propr <- function(counts,
   ##############################################################################
 
   message("Alert: Use 'updateCutoffs' to calculate FDR.")
-
+  NVTX_POP()
   return(result)
-}
+}

R/10-nvtx-shim.R

@@ -0,0 +1,20 @@
+.nvtx_enabled <- function() {
+  isTRUE(getOption("propr.enable_nvtx", FALSE)) && requireNamespace("nvtxR", quietly = TRUE)
+}
+
+NVTX_PUSH <- function(label, color = 0L) {
+  if (.nvtx_enabled()) nvtxR::nvtx_push_range(label, as.integer(color))
+  invisible(NULL)
+}
+NVTX_POP <- function() {
+  if (.nvtx_enabled()) nvtxR::nvtx_pop_range()
+  invisible(NULL)
+}
+
+WITH_NVTX <- function(label, color = 0L, expr) {
+  if (.nvtx_enabled()) {
+    nvtxR::nvtx_push_range(label, as.integer(color))
+    on.exit(nvtxR::nvtx_pop_range(), add = TRUE)
+  }
+  eval.parent(substitute(expr))
+}

R/1a-propr-backend.R

@@ -214,6 +214,7 @@ logratio <- function(counts, ivar, alpha=NA) {
 #'
 #' @export
 pcor.bshrink <- function(ct, outtype = c("clr", "alr")) {
+  NVTX_PUSH("pcor.bshrink", 0)
   packageCheck("corpcor")
   outtype <- match.arg(outtype)
 
@@ -225,6 +226,7 @@ pcor.bshrink <- function(ct, outtype = c("clr", "alr")) {
   lambda <- attr(covB, "lambda")
 
   # convert basis covariance matrix to clr/alr covariance matrix
+  NVTX_PUSH("basis covariance matrix to clr/alr", 0)
   D  <- ncol(ct)
   if (outtype == "alr") {
     F   <- cbind(diag(rep(1, D - 1)), rep(-1, D - 1))
@@ -233,9 +235,12 @@ pcor.bshrink <- function(ct, outtype = c("clr", "alr")) {
     G   <- diag(rep(1, D)) - matrix(1 / D, D, D)
     cov <- G %*% covB %*% G
   }
+  NVTX_POP()
 
   # partial correlation
+  NVTX_PUSH("corpcor::cor2pcor", 0)
   pcor <- corpcor::cor2pcor(cov)
+  NVTX_POP()
 
   # make output to have same dimensions as input
   # alr partial correlation has one less dimension,
@@ -245,6 +250,6 @@ pcor.bshrink <- function(ct, outtype = c("clr", "alr")) {
     pcor <- rbind(pcor, 0)
     pcor[ncol(pcor), ncol(pcor)] <- 1
   }
-
+  NVTX_POP()
   return(list(matrix = pcor, lambda = lambda))
-}
+}