notkshitij/nvcc
1
0
Fork 0
mirror of https://github.com/andreinechaev/nvcc4jupyter.git synced 2026-06-13 18:50:47 +05:30
Code Issues Packages Projects Releases Wiki Activity

Add option to choose between NSYS and NCU profilers (#28)

Browse Source 
* Add option to give nvcc extra arguments

* Add test for nvcc options that changes c++ dialect from c++17 to c++14

* Add make and the english language pack to devcontainer to be able to build the documentation

* Update documentation config to automatically import the current version of the package

* Document new --compiler-args argument

* Improve tests coverage by testing for bad arguments and the error output during a failed compilation

* Add IPython to docs requirements to allow the __version__ import for readthedocs env

* Change devcontainer base image to have the latest CUDA toolkit

* Mock the nsight compute tool with a bash script

* Add test to compile with opencv

* Add new page to documentation that contains a new notebook that explains compiling with external libraries

* Add autodocstring vscode extension to devcontainer

* Add function that modifies the default profiler/compiler arguments to allow reusing them in multiple magic command calls

* Update pylint exceptions

* Update contributing instructions

* Change version from 1.0.3 to 1.1.0 due to adding features in a backward-compatible manner

* Install latest CUDA toolkit on the test runner to pass the OpenCV compilation test

* Install opencv in test runner and update code coverage install

* Add CUDA bin to PATH in test and coverage runners

* Add cuda bin to path variable in .bashrc

* Update way to set environment variable PATH in github action

* Change devcontainer base image back to ubuntu:22.04 to match the environment from the test runner

* Add option to choose between NSYS and NCU profilers

* Add tests for choosing the profiler

* Add isort config to help it find local modules so they are not considered 3rd party libraries

* Replace experimental-string-processing black formatter config with enable-unstable-feature as it was removed in version 24.1.0

* Search for profiling tools executable paths when they are required

* Install dev dependencies in editable mode

* Add documentation for using Nsight Systems instead of the default Nsight Compute profiling tool

* Fix cuda typo

* Mention Nsight Systems in README.md
This commit is contained in:
Cosmin Ștefan Ciocan
2024-03-20 11:42:27 +01:00
committed by GitHub
parent 781ff5b76b
commit 0bddf6a6e6
15 changed files with 293 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nvcc4jupyter/__init__.py
+1 -1
View File
@@ -2,7 +2,7 @@
nvcc4jupyter: CUDA C++ plugin for Jupyter Notebook
"""
from .parsers import set_defaults # noqa: F401
from .parsers import Profiler, set_defaults # noqa: F401
from .plugin import NVCCPlugin, load_ipython_extension # noqa: F401
__version__ = "1.1.0"
nvcc4jupyter/parsers.py
+36 -6
View File
@@ -3,14 +3,28 @@ Parsers for the CUDA magic commands.
"""
import argparse
from typing import Callable, Optional
from enum import Enum
from typing import Callable, Optional, Type, TypeVar
class Profiler(Enum):
"""Choice between Nsight Compute and Nsight Systems profilers."""
NCU = "ncu"
NSYS = "nsys"
_default_profiler: Profiler = Profiler.NCU
_default_profiler_args: str = ""
_default_compiler_args: str = ""
T = TypeVar("T")
def set_defaults(
compiler_args: Optional[str] = None, profiler_args: Optional[str] = None
profiler: Optional[Profiler] = None,
compiler_args: Optional[str] = None,
profiler_args: Optional[str] = None,
) -> None:
"""
Set the default values for various arguments of the magic commands. These
@@ -18,17 +32,22 @@ def set_defaults(
to override this behaviour on a cell by cell basis.
Args:
profiler: If not None, this value becomes the new default profiler.
Defaults to None.
compiler_args: If not None, this value becomes the new default compiler
config. Defaults to "".
config. Defaults to None.
profiler_args: If not None, this value becomes the new default profiler
config. Defaults to "".
config. Defaults to None.
"""
# pylint: disable=global-statement
global _default_profiler
if profiler is not None:
_default_profiler = profiler
global _default_compiler_args
global _default_profiler_args
if compiler_args is not None:
_default_compiler_args = compiler_args
global _default_profiler_args
if profiler_args is not None:
_default_profiler_args = profiler_args
@@ -38,6 +57,11 @@ def str_to_lambda(arg: str) -> Callable[[], str]:
return lambda: arg
def class_to_lambda(arg: str, cls: Type[T]) -> Callable[[], T]:
"""Convert string value to class and then to lambda"""
return lambda: cls(arg)
def get_parser_cuda() -> argparse.ArgumentParser:
"""
%%cuda magic command parser.
@@ -52,8 +76,14 @@ def get_parser_cuda() -> argparse.ArgumentParser:
parser.add_argument("-t", "--timeit", action="store_true")
parser.add_argument("-p", "--profile", action="store_true")
# --profiler-args and --compiler-args values are lambda functions to allow
# the type of the following arguments is a lambda lambda function to allow
# changing the default value at runtime
parser.add_argument(
"-l",
"--profiler",
type=lambda arg: class_to_lambda(arg, cls=Profiler),
default=lambda: _default_profiler,
)
parser.add_argument(
"-a",
"--profiler-args",
nvcc4jupyter/path_utils.py
+61
View File
@@ -0,0 +1,61 @@
"""
Helper functions relating to file paths.
"""
import os
from glob import glob
from typing import List, Optional
CUDA_SEARCH_PATHS: List[str] = [
"/opt/nvidia/nsight-compute",
"/usr/local/cuda",
"/opt",
"/usr",
]
def is_executable(fpath: str) -> bool:
"""Check if file exists and is executable"""
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
def which(name: str) -> Optional[str]:
"""Find an executable by name by searching the PATH directories"""
for path_dir in os.environ.get("PATH", "").split(os.pathsep):
exec_path = os.path.join(path_dir, name)
if is_executable(exec_path):
return exec_path
return None
def find_executable(
name: str, search_paths: Optional[List[str]] = None
) -> Optional[str]:
"""
Find an executable, either by searching in the directories of the PATH
environment variable or, if that did not work, by searching recursively
in directories a list given as parameter.
Args:
name: The name of the executable to be found.
search_paths: If None, only executables that are available from PATH
will be found. Otherwise, will recursively search these
directories. Defaults to None.
Returns:
The path to the executable if it is found, and None otherwise.
"""
if search_paths is None:
search_paths = []
which_path = which(name)
if which_path is not None:
return which_path
for search_path in search_paths:
search_path = os.path.abspath(search_path)
search_path = os.path.join(search_path, f"**/{name}")
for exec_path in glob(search_path, recursive=True):
return exec_path
return None
nvcc4jupyter/plugin.py
+56 -10
View File
@@ -9,13 +9,20 @@ import shutil
import subprocess
import tempfile
import uuid
from typing import List, Optional
from typing import Dict, List, Optional
# pylint: disable=import-error
from IPython.core.interactiveshell import InteractiveShell
from IPython.core.magic import Magics, cell_magic, line_magic, magics_class
from . import parsers
from .parsers import (
Profiler,
get_parser_cuda,
get_parser_cuda_group_delete,
get_parser_cuda_group_run,
get_parser_cuda_group_save,
)
from .path_utils import CUDA_SEARCH_PATHS, find_executable
DEFAULT_EXEC_FNAME = "cuda_exec.out"
SHARED_GROUP_NAME = "shared"
@@ -37,14 +44,19 @@ class NVCCPlugin(Magics):
super().__init__(shell)
self.shell: InteractiveShell # type hint not provided by parent class
self.parser_cuda = parsers.get_parser_cuda()
self.parser_cuda_group_save = parsers.get_parser_cuda_group_save()
self.parser_cuda_group_delete = parsers.get_parser_cuda_group_delete()
self.parser_cuda_group_run = parsers.get_parser_cuda_group_run()
self.parser_cuda = get_parser_cuda()
self.parser_cuda_group_save = get_parser_cuda_group_save()
self.parser_cuda_group_delete = get_parser_cuda_group_delete()
self.parser_cuda_group_run = get_parser_cuda_group_run()
self.workdir = tempfile.mkdtemp()
print(f'Source files will be saved in "{self.workdir}".')
self.profiler_paths: Dict[Profiler, Optional[str]] = {
Profiler.NCU: None,
Profiler.NSYS: None,
}
def _save_source(
self, source_name: str, source_code: str, group_name: str
) -> None:
@@ -135,11 +147,42 @@ class NVCCPlugin(Magics):
return executable_fpath
def _run(
def _get_profiler_path(self, profiler: Profiler) -> str:
"""
Get the path of the executable of a given profiling tool. Searches
the directories of the PATH environment variable and some extra
directories where CUDA is usually installed.
Args:
profiler: The profiler whose executable should be found.
Raises:
RuntimeError: If the profiler executable could not be found.
Returns:
The file path of the executable.
"""
profiler_path = self.profiler_paths[profiler]
if profiler_path is not None:
return profiler_path
profiler_path = find_executable(profiler.value, CUDA_SEARCH_PATHS)
if profiler_path is None:
raise RuntimeError(
f'Could not find the "{profiler.value}" profiling tool.'
" Consider searching for where it is installed and adding its"
" directory to the PATH environment variable."
)
self.profiler_paths[profiler] = profiler_path
return profiler_path
def _run( # pylint: disable=too-many-arguments
self,
exec_fpath: str,
timeit: bool = False,
profile: bool = False,
profiler: Profiler = Profiler.NCU,
profiler_args: str = "",
) -> str:
"""
@@ -150,8 +193,9 @@ class NVCCPlugin(Magics):
timeit: If True, returns the result of the "timeit" magic instead
of the standard output of the CUDA process. Defaults to False.
profile: If True, the executable is profiled with NVIDIA Nsight
Compute profiling tool and its output is added to stdout.
Defaults to False.
Compute or NVIDIA Nsight Systems and the profiling output is
added to stdout. Defaults to False.
profiler: The profiling tool to use.
profiler_args: The profiler arguments used to customize the
information gathered by it and its overall behaviour. Defaults
to an empty string.
@@ -173,7 +217,8 @@ class NVCCPlugin(Magics):
else:
run_args = []
if profile:
run_args.extend(["ncu"] + profiler_args.split())
profiler_path = self._get_profiler_path(profiler)
run_args.extend([profiler_path] + profiler_args.split())
run_args.append(exec_fpath)
output = subprocess.check_output(
run_args, stderr=subprocess.STDOUT
@@ -194,6 +239,7 @@ class NVCCPlugin(Magics):
exec_fpath=exec_fpath,
timeit=args.timeit,
profile=args.profile,
profiler=args.profiler(),
profiler_args=args.profiler_args(),
)
except subprocess.CalledProcessError as e: