Installing ROOT fully on windows

Aditya_Sharma · December 25, 2024, 11:30pm

I have downloaded ROOT 6.32.06 on my device but it doesnot have ‘pyroot’ and ‘cuda’ capabilities maybe because i downloaded it form the ‘.exe’ installer on the website can someone guide me what to do in order to install the full version of root on windows manually because I think installer will not include the features that I want.
ROOT Version: 6.32.06
Platform: W11 23H2
Compiler: Visual Studio??

Danilo · December 26, 2024, 7:54am

Hi Aditya,

Over here it’s holiday season: expect perhaps some delays in the answers.
Let me add in the loop @bellenot .
In the meanwhile, I can propose to have a look to 6.34.02: Release 63402 - ROOT

Let us know how this goes.

Cheers,
D

Aditya_Sharma · December 30, 2024, 4:20pm

Hi Danilo,

Thank you for the update! I completely understand that it’s the holiday season and that there may be some delays in responses. I’ll wait for you to come back with more details and for @bellenot to be added to the loop.

I would also like to ask if there is a way to install/build root on windows from scratch without requiring the MVSC compiler that comes with visual studio because that compiler is highly unoptimized and folders created by visual studio take enormous amounts of space.
A rough comparison of performance can be checked in ROOT Performance in Linux vs Windows - ROOT - ROOT Forum

Looking forward to hearing back from you.

Cheers,
Aditya

bellenot · January 6, 2025, 8:33am

Hi,

First, sorry for the delay. Then, PyROOT should be available with the binaries, but not CUDA (we never tried to enable CUDA on Windows). And Visual Studio is required. Note that you can also use WSL as an alternative…

Cheers, Bertrand.

Aditya_Sharma · January 18, 2025, 5:40am

Hi Bellenot,
Sure, I will try installing CUDA on my WSL, in the meantime can you tell me detailed steps to install root in WSL with CUDA. I tried to find detaild instructions but I was unable to do so. I am planning to use Ubuntu 24.04.1 LTS available on Microsoft Store (which I guess is WSL2).
Also, I was not able to find a proper list of compatible CUDA versions (like TensorFlow supports version 12.3 and PyTorch supports version 12.4), can I get more info on that so that I download other things in WSL accordingly.
Cheers,
Aditya

bellenot · January 20, 2025, 8:03am

I have no experience with CUDA either on Windows or Ubuntu. Did you try to search the forum? Or maybe @jonas or @moneta can help

ferhue · January 20, 2025, 9:49am

CUDA related:

github.com/root-project/root

Allow compilation with NVIDIA nvc++

opened 11:50PM - 18 Nov 24 UTC

cgleggett

improvement

### Explain what you would like to see improved and how. The main obstacle to… compiling root with nvc++ is the extraction of the system headers by cling. With gcc, this is done via `g++ -xc++ -E -v /dev/null` and then a sed script to extract the paths in interpreter/cling/lib/Interpreter/CMakeLists.cxx. This doesn't work with nvc++, but a new flag in hpc sdk version 24.11 was added explicitly for this: `-drygccinc`. I can offer a patch for this file, but there are a LOT of different code paths through it, and I'm not certain of what they all do, so I probably haven't covered all use cases: ``` diff --git a/interpreter/cling/lib/Interpreter/CMakeLists.txt b/interpreter/cling/lib/Interpreter/CMakeLists.txt index e397da97f6..7639cbc58e 100644 --- a/interpreter/cling/lib/Interpreter/CMakeLists.txt +++ b/interpreter/cling/lib/Interpreter/CMakeLists.txt @@ -242,24 +242,34 @@ if (UNIX) endif() if(NOT CLING_CXX_HEADERS) - if (CLING_CXX_PATH) - execute_process(COMMAND ${CLING_CXX_PATH} ${CLING_CXX_PATH_ARGS} -xc++ -E -v /dev/null + + if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "NVHPC") + execute_process(COMMAND ${CLING_CXX_RLTV} -drygccinc OUTPUT_QUIET ERROR_VARIABLE CLING_CXX_HEADERS) - set(CLING_CXX_PATH "${CLING_CXX_PATH} ${CLING_CXX_PATH_ARGS}") + execute_process( + COMMAND echo ${CLING_CXX_HEADERS} + COMMAND sed s/:/\\\n/g + OUTPUT_VARIABLE CLING_CXX_HEADERS) else() - # convert CMAKE_CXX_FLAGS to a list for execute_process - string(REPLACE "-fdiagnostics-color=always" "" cling_tmp_arg_list ${CMAKE_CXX_FLAGS}) - string(REPLACE "-fcolor-diagnosics" "" cling_tmp_arg_list ${cling_tmp_arg_list}) - string(REPLACE " " ";" cling_tmp_arg_list ${cling_tmp_arg_list}) - execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${cling_tmp_arg_list} -xc++ -E -v /dev/null - OUTPUT_QUIET ERROR_VARIABLE CLING_CXX_HEADERS) + if (CLING_CXX_PATH) + execute_process(COMMAND ${CLING_CXX_PATH} ${CLING_CXX_PATH_ARGS} -xc++ -E -v /dev/null + OUTPUT_QUIET ERROR_VARIABLE CLING_CXX_HEADERS) + set(CLING_CXX_PATH "${CLING_CXX_PATH} ${CLING_CXX_PATH_ARGS}") + else() + # convert CMAKE_CXX_FLAGS to a list for execute_process + string(REPLACE "-fdiagnostics-color=always" "" cling_tmp_arg_list ${CMAKE_CXX_FLAGS}) + string(REPLACE "-fcolor-diagnosics" "" cling_tmp_arg_list ${cling_tmp_arg_list}) + string(REPLACE " " ";" cling_tmp_arg_list ${cling_tmp_arg_list}) + execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${cling_tmp_arg_list} -xc++ -E -v /dev/null + OUTPUT_QUIET ERROR_VARIABLE CLING_CXX_HEADERS) + endif() + + execute_process( + COMMAND echo ${CLING_CXX_HEADERS} + COMMAND sed -n -e /^.include/,\$\{ -e /^\\\ \\\/.*++/p -e \} + OUTPUT_VARIABLE CLING_CXX_HEADERS) endif() - execute_process( - COMMAND echo ${CLING_CXX_HEADERS} - COMMAND sed -n -e /^.include/,\$\{ -e /^\\\ \\\/.*++/p -e \} - OUTPUT_VARIABLE CLING_CXX_HEADERS) - stripNewLine("${CLING_CXX_HEADERS}" CLING_CXX_HEADERS) endif() ``` Also, we can add NVHPC to the list of supported compilers in cmake/modules/CheckCompiler.cmake: ``` diff --git a/cmake/modules/CheckCompiler.cmake b/cmake/modules/CheckCompiler.cmake index 4efd0b5946..64ed9761ff 100644 --- a/cmake/modules/CheckCompiler.cmake +++ b/cmake/modules/CheckCompiler.cmake @@ -8,7 +8,7 @@ # CheckCompiler.cmake #--------------------------------------------------------------------------------------------------- -if(NOT CMAKE_CXX_COMPILER_ID MATCHES "(Apple|)Clang|GNU|Intel|MSVC") +if(NOT CMAKE_CXX_COMPILER_ID MATCHES "(Apple|)Clang|GNU|Intel|MSVC|NVHPC") message(WARNING "Unsupported compiler: ${CMAKE_CXX_COMPILER_ID}.") endif() ``` ### ROOT version tried with 6.33.01 ### Installation method build from source ### Operating system linux alma9 ### Additional context requires at least v24.11 of NVIDIA nvc++

github.com/root-project/root

WIP: Add support for NVIDIA nvc++ compiler

root-project:master ← cgleggett:dev/support_nvhpc

opened 09:37PM - 20 Nov 24 UTC

cgleggett

+32 -15

# This Pull request: Adds support for NVIDIA's nvc++ compiler Fixes https:…//github.com/root-project/root/issues/16975 ## Changes or fixes: - check if at least ver 24.11 of nvc++ compiler is being used - when building cling, nvc++ uses a different syntax than gcc to extract the system include header locations. Instead of -xc++ -E -v, and then a bunch of sed parsing, it uses the -drygccinc flag to produce a colon separated list of paths. This allows clean compilation on ARM (NVIDIA Grace) CPUs.

jonas · January 20, 2025, 10:10am

@ferhue, the GitHub items you linked are about compiling all of ROOT with the Nvidia compiler, not the CUDA features in particular.

@Aditya_Sharma, are you sure you need the “cuda” features? For now, the only CUDA features in ROOT are the TMVA and RooFit CUDA backends, and most of our ROOT users don’t even use RooFit or TMVA.

Nobody here has experience with ROOT+Cuda on WSL, so getting help will be hard. Let’s first try to figure out if this is really necessary. If you just want to enable “cuda” for the sake of having a “full build of ROOT”, I can already tell you it’s not worth it.

Aditya_Sharma · January 20, 2025, 11:01am

Hi Jonas,

I don’t remember all the features I used earlier when I first wrote a code in ROOT about a year ago, I remember that at the very end I had to use ROO Stats to analyze data from 10 files combined, this took a lot of time on the window’s native version of ROOT, and this was frustrating for me as many times the code didn’t work. So, I wanted CUDA so that I can analyze files much quicker.

Also, I now wanted to try to write a Deep Learning code for these files, so I was hoping to have CUDA C++ support.

jonas · January 20, 2025, 1:35pm

What kind of fits are you doing in your RooStats analysis? The CUDA backend can give a significant speedup for unbinned fits where the likelihood function sums over millions of events or more. But it doesn’t give any advantage for binned fits, because often one doesn’t have many bins anyway and potential for parallelization is low. For the big unbinned fits it’s worth it though!

And what do you mean with “deep learning code”? Nowadays, one usually trains the deep neural networks outside ROOT with pytorch or tensorflow. Or you plan to use something else? In that case, this has nothing to do with the CUDA features of ROOT.

Aditya_Sharma · January 20, 2025, 3:05pm

As far as I can tell by looking at the code, the code I wrote was for ‘unbinned’ fits, where I did not explicitly group data, I used RooDataSet to perform the fit.

For Deep Learning part, I was mostly planning to write code in PyRoot using PyTorch and if I have some free time then trying to write a DL code from scratch in CUDA C++ for “.root” files.