### __cu_demangle example output Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Output of the __cu_demangle example: fake mangled name returns null with status -2 (not a valid mangled id), real mangled name returns the demangled name with status 0 (success). ```text fake_mangled_name: result => (null) status => -2 real_mangled_name: result => clstmp01::clstmp01_mf01() status => 0 ``` -------------------------------- ### Boolean, single value, and list option examples Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Shows the three command-line option types: boolean (nvdisasm --print-raw), single value (nvdisasm --binary SM100), and list (cuobjdump --function). Boolean options take no argument; single value options appear at most once; list options may be repeated. ```bash Boolean option : nvdisasm --print-raw Single value : nvdisasm --binary SM100 List options : cuobjdump --function "foo,bar,foobar" ``` -------------------------------- ### Example JSON output from nvdisasm -json Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Example of the JSON output from nvdisasm -json [-g] after beautifying. The output is minified by default; this sample shows the structure with ELF, SM, SchemaVersion, function entries, and source file directories. ```json [ { "ELF": { "layout-id": 4, "ei_osabi": 65, "ei_abiversion": 8 }, "SM": { "version": { "major": 9, "minor": 0 } }, "SchemaVersion": { "major": 13, "minor": 4, "revision": 0 }, "Producer": "nvdisasm V13.4.0 Build 12345", "Description": "" }, [ { "function-name": "matmul_kernel", "start": 0, "length": 13312, "other-attributes": [], "sass-instructions": [ { "opcode": "LDC", "operands": "R1,c[0x0][0x28]", "source-file-id": 0, "source-line": 267 }, { "opcode": "S2R", "operands": "R0,SR_TID.X" }, { "opcode": "ULDC.64", "operands": "UR20,c[0x0][0x198]" }, { "opcode": "USHF.R.S32.HI", "operands": "UR5,URZ,0x1f,UR4", "source-file-id": 2, "source-line": 41 }, { "opcode": "HGMMA.64x256x16.F32", "operands": "R24,gdesc[UR8].tnspB,R24", "source-file-id": 0, "source-line": 416 }, { "opcode": "EXIT", "other-attributes": { "control-flow": "True" }, "source-file-id": 0, "source-line": 267 }, { "opcode": "IMAD.MOV.U32", "operands": "R6,RZ,RZ,R12", "source-file-id": 1, "source-line": 55 } ] }, { "function-name": "bar", "start": 13312, "length": 32, "other-attributes": [], "sass-instructions": [ { "opcode": "STS.128", "operands": "[UR5+0x400],RZ" }, { "opcode": "RET.REL.NODEC", "operands": "R18,`(matmul_kernel)", "other-attributes": { "control-flow": "True" } } ] } ], { "directories": [ "/path/to", "/path/to/triton/language" ], "files": [ { "dir-idx": 0, "file": "hopper-gemm-ws.py" }, { "dir-idx": 0, "file": "blackwell-gemm-ws.py" }, { "dir-idx": 1, "file": "standard.py" } ] } ] ``` -------------------------------- ### nvprune -arch sm_120 example Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Prunes libcublas_static.a to only contain sm_120 cubin. The resulting library will not run on any other architecture, so use only when building for a single architecture. ```bash nvprune -arch sm_120 libcublas_static.a -o libcublas_static120.a ``` -------------------------------- ### __cu_demangle example usage Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Example usage of __cu_demangle from nv_decode.h. It demangles a fake and a real mangled name, printing results and status codes. The function is thread-safe and the caller must free the returned memory. ```c #include #include #include "nv_decode.h" int main() { int status; const char *real_mangled_name="_ZN8clstmp01I5cls01E13clstmp01_mf01Ev"; const char *fake_mangled_name="B@d_iDentiFier"; char* realname = __cu_demangle(fake_mangled_name, 0, 0, &status); printf("fake_mangled_name:\t result => %s\t status => %d\n", realname, status); free(realname); size_t size = sizeof(char)*1000; realname = (char*)malloc(size); __cu_demangle(real_mangled_name, realname, &size, &status); printf("real_mangled_name:\t result => %s\t status => %d\n", realname, status); free(realname); return 0; } ``` -------------------------------- ### cuobjdump --help Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Prints help information on this tool. ```APIDOC ## cuobjdump --help ### Description Print this help information on this tool. ### Method CLI ### Endpoint cuobjdump --help ### Parameters #### Command-Line Options - **--help** (flag) - Required - Print help information. ### Request Example ``` $ cuobjdump --help ``` ### Response #### Success Response Prints help information. ``` -------------------------------- ### cuobjdump --options-file Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Includes command line options from specified file. ```APIDOC ## cuobjdump --options-file ,... ### Description Include command line options from specified file. ### Method CLI ### Endpoint cuobjdump --options-file ,... ### Parameters #### Command-Line Options - **--options-file** (string) - Required - Comma-separated file paths containing command-line options. ### Request Example ``` $ cuobjdump --options-file options.txt ``` ### Response #### Success Response Includes command-line options from the specified file. ``` -------------------------------- ### cuobjdump --dump-resource-usage Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Dumps resource usage for each ELF. Useful in getting all the resource usage information at one place. ```APIDOC ## cuobjdump --dump-resource-usage ### Description Dump resource usage for each ELF. Useful in getting all the resource usage information at one place. ### Method CLI ### Endpoint cuobjdump --dump-resource-usage ### Parameters #### Command-Line Options - **--dump-resource-usage** (flag) - Required - Dump resource usage for each ELF. ### Request Example ``` $ cuobjdump --dump-resource-usage ``` ### Response #### Success Response Dumps resource usage for each ELF. ``` -------------------------------- ### nvprune Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Command-line tool usage and options for nvprune. ```APIDOC ## nvprune ### Description Prunes host object files and static libraries to only contain device code for the specified targets. ### Usage ``` nvprune [options] -o ``` ### Parameters #### Input File - **infile** (file path) - Required - The input file must be a relocatable host object or static library (not a host executable). #### Output File - **outfile** (file path) - Required - The output file will be the same format as the input file. ### Options - **--arch ,...** (string) - Optional - Specify the name of the NVIDIA GPU architecture which will remain in the object or library. Short name: `-arch`. - **--generate-code** (string) - Optional - Same format as nvcc `--generate-code` option; provides a way to specify multiple architectures which should remain. Only the 'code' values are used as targets to match. Allowed keywords: 'arch', 'code'. Short name: `-gencode`. - **--no-relocatable-elf** (flag) - Optional - Don't keep any relocatable ELF. Short name: `-no-relocatable-elf`. - **--output-file** (string) - Required - Specify name and location of the output file. Short name: `-o`. - **--help** (flag) - Optional - Print help information on this tool. Short name: `-h`. - **--options-file ,...** (string) - Optional - Include command line options from specified file. Short name: `-optf`. - **--version** (flag) - Optional - Print version information on this tool. Short name: `-V`. ### Example ``` nvprune -arch sm_120 libcublas_static.a -o libcublas_static120.a ``` ### Notes - Either `--arch` or `--generate-code` must be used to specify the target(s) to keep. - All other device code is discarded from the file. - Targets can be either a `sm_NN` arch (cubin) or `compute_NN` arch (ptx). ``` -------------------------------- ### nvdisasm -gi output with source line and inlining info Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Sample output of `nvdisasm -gi` for a kernel, showing SASS instructions with source line information and inlining info. The `//##` comments indicate the original source file and line, including inlined function calls. Use this to understand how `-gi` augments disassembly with line and inlining details. ```sass //--------------------- .text._Z6kernali -------------------------- .section .text._Z6kernali,"ax",@progbits .sectioninfo @"SHI_REGISTERS=16" .align 128 .global _Z6kernali .type _Z6kernali,@function .size _Z6kernali,(.L_18 - _Z6kernali) .other _Z6kernali,@"STO_CUDA_ENTRY STV_DEFAULT" _Z6kernali: .text._Z6kernali: /*0000*/ IMAD.MOV.U32 R1, RZ, RZ, c[0x0][0x28] ; //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*0010*/ UMOV UR4, 32@lo(arr) ; /*0020*/ UMOV UR5, 32@hi(arr) ; /*0030*/ IMAD.U32 R2, RZ, RZ, UR4 ; /*0040*/ MOV R3, UR5 ; /*0050*/ ULDC.64 UR4, c[0x0][0x118] ; //## File "/home/user/cuda/inline.cu", line 10 inlined at "/home/user/cuda/inline.cu", line 17 //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*0060*/ LDG.E R4, [R2.64] ; /*0070*/ LDG.E R5, [R2.64+0x4] ; //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*0080*/ LDG.E R0, [R2.64+0x8] ; //## File "/home/user/cuda/inline.cu", line 23 /*0090*/ UMOV UR6, 32@lo(ans) ; /*00a0*/ UMOV UR7, 32@hi(ans) ; //## File "/home/user/cuda/inline.cu", line 10 inlined at "/home/user/cuda/inline.cu", line 17 //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*00b0*/ IADD3 R7, R4, c[0x0][0x160], RZ ; //## File "/home/user/cuda/inline.cu", line 23 /*00c0*/ IMAD.U32 R4, RZ, RZ, UR6 ; //## File "/home/user/cuda/inline.cu", line 10 inlined at "/home/user/cuda/inline.cu", line 17 //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*00d0*/ IADD3 R9, R5, c[0x0][0x160], RZ ; //## File "/home/user/cuda/inline.cu", line 23 /*00e0*/ MOV R5, UR7 ; //## File "/home/user/cuda/inline.cu", line 10 inlined at "/home/user/cuda/inline.cu", line 17 //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*00f0*/ IADD3 R11, R0.reuse, c[0x0][0x160], RZ ; //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*0100*/ IMAD.IADD R13, R0, 0x1, R7 ; //## File "/home/user/cuda/inline.cu", line 10 inlined at "/home/user/cuda/inline.cu", line 17 //## File "/home/user/cuda/inline.cu", line 17 inlined at "/home/user/cuda/inline.cu", line 23 //## File "/home/user/cuda/inline.cu", line 23 /*0110*/ STG.E [R2.64+0x4], R9 ; /*0120*/ STG.E [R2.64], R7 ; /*0130*/ STG.E [R2.64+0x8], R11 ; //## File "/home/user/cuda/inline.cu", line 23 /*0140*/ STG.E [R4.64], R13 ; //## File "/home/user/cuda/inline.cu", line 24 /*0150*/ EXIT ; .L_3: /*0160*/ BRA (.L_3); .L_18: ``` -------------------------------- ### cuobjdump --extract-ptx Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Extracts PTX file(s) name containing and saves as file(s). Use `all` to extract all files. To get the list of PTX files use -lptx option. Works with host executable/object/library and external fatbin. All `dump` and `list` options are ignored with this option. ```APIDOC ## cuobjdump --extract-ptx ,... ### Description Extract PTX file(s) name containing and save as file(s). Use `all` to extract all files. To get the list of PTX files use -lptx option. Works with host executable/object/library and external fatbin. All `dump` and `list` options are ignored with this option. ### Method CLI ### Endpoint cuobjdump --extract-ptx ,... ### Parameters #### Command-Line Options - **--extract-ptx** (string) - Required - Comma-separated partial file names to extract. Use `all` to extract all files. ### Request Example ``` $ cuobjdump --extract-ptx all ``` ### Response #### Success Response Extracts PTX file(s) and saves them as file(s). ``` -------------------------------- ### cuobjdump --extract-elf Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Extracts ELF file(s) name containing and saves as file(s). Use `all` to extract all files. To get the list of ELF files use -lelf option. Works with host executable/object/library and external fatbin. All `dump` and `list` options are ignored with this option. ```APIDOC ## cuobjdump --extract-elf ,... ### Description Extract ELF file(s) name containing and save as file(s). Use `all` to extract all files. To get the list of ELF files use -lelf option. Works with host executable/object/library and external fatbin. All `dump` and `list` options are ignored with this option. ### Method CLI ### Endpoint cuobjdump --extract-elf ,... ### Parameters #### Command-Line Options - **--extract-elf** (string) - Required - Comma-separated partial file names to extract. Use `all` to extract all files. ### Request Example ``` $ cuobjdump --extract-elf all ``` ### Response #### Success Response Extracts ELF file(s) and saves them as file(s). ``` -------------------------------- ### nvprune basic usage Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Basic usage of nvprune. Accepts a single input file and emits a new output file. The input must be a relocatable host object or static library, not a host executable. ```bash nvprune [options] -o ``` -------------------------------- ### Sample cuobjdump -ptx -sass output Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Sample output of cuobjdump -ptx -sass on add.o, showing the fatbin ELF header, target architecture sm_100, and the SASS disassembly for the function _Z3addPfS_S_. ```bash $ cuobjdump -ptx -sass add.o Fatbin elf code: ================ arch = sm_100 code version = [1,8] host = linux compile_size = 64bit code for sm_100 .target sm_100 Function : _Z3addPfS_S_ .headerflags @"EF_CUDA_SM100 EF_CUDA_VIRTUAL_SM(EF_CUDA_SM100)" /*0000*/ LDC R1, c[0x0][0x37c] ; /* 0x0000df00ff017b82 */ /* 0x000fe20000000800 */ /*0010*/ S2R R9, SR_TID.X ; /* 0x0000000000097919 */ /* 0x000e2e0000002100 */ /*0020*/ S2UR UR6, SR_CTAID.X ; /* 0x00000000000679c3 */ /* 0x000e220000002500 */ /*0030*/ LDCU.64 UR4, c[0x0][0x358] ; /* 0x00006b00ff0477ac */ /* 0x000e6e0008000a00 */ /*0040*/ LDC R0, c[0x0][0x360] ; /* 0x0000d800ff007b82 */ /* 0x000e300000000800 */ /*0050*/ LDC.64 R2, c[0x0][0x380] ; /* 0x0000e000ff027b82 */ /* 0x000eb00000000a00 */ /*0060*/ LDC.64 R4, c[0x0][0x388] ; /* 0x0000e200ff047b82 */ /* 0x000ee20000000a00 */ /*0070*/ IMAD R9, R0, UR6, R9 ; /* 0x0000000600097c24 */ /* 0x001fce000f8e0209 */ /*0080*/ LDC.64 R6, c[0x0][0x390] ; /* 0x0000e400ff067b82 */ /* 0x000e220000000a00 */ /*0090*/ IMAD.WIDE R2, R9, 0x4, R2 ; /* 0x0000000409027825 */ /* 0x004fcc00078e0202 */ /*00a0*/ LDG.E R2, desc[UR4][R2.64] ; /* 0x0000000402027981 */ /* 0x002ea2000c1e1900 */ /*00b0*/ IMAD.WIDE R4, R9, 0x4, R4 ; /* 0x0000000409047825 */ /* 0x008fcc00078e0204 */ /*00c0*/ LDG.E R5, desc[UR4][R4.64] ; /* 0x0000000404057981 */ /* 0x000ea2000c1e1900 */ /*00d0*/ IMAD.WIDE R6, R9, 0x4, R6 ; /* 0x0000000409067825 */ /* 0x001fc800078e0206 */ /*00e0*/ FADD R9, R2, R5 ; /* 0x0000000502097221 */ /* 0x004fca0000000000 */ /*00f0*/ STG.E desc[UR4][R6.64], R9 ; /* 0x0000000906007986 */ /* 0x000fe2000c101904 */ /*0100*/ EXIT ; /* 0x000000000000794d */ /* 0x000fea0003800000 */ /*0110*/ BRA 0x110; /* 0xfffffffc00fc7947 */ /* 0x000fc0000383ffff */ /*0120*/ NOP; /* 0x0000000000007918 */ ``` -------------------------------- ### cuobjdump --extract-text Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Extracts text binary encoding file(s) name containing and saves as file(s). Use ‘all’ to extract all files. To get the list of text binary encoding use -ltext option. All ‘dump’ and ‘list’ options are ignored with this option. ```APIDOC ## cuobjdump --extract-text ,... ### Description Extract text binary encoding file(s) name containing and save as file(s). Use ‘all’ to extract all files. To get the list of text binary encoding use -ltext option. All ‘dump’ and ‘list’ options are ignored with this option. ### Method CLI ### Endpoint cuobjdump --extract-text ,... ### Parameters #### Command-Line Options - **--extract-text** (string) - Required - Comma-separated partial file names to extract. Use `all` to extract all files. ### Request Example ``` $ cuobjdump --extract-text all ``` ### Response #### Success Response Extracts text binary encoding file(s) and saves them as file(s). ``` -------------------------------- ### cuobjdump --list-elf Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Lists all the ELF files available in the fatbin. Works with host executable/object/library and external fatbin. All other options are ignored with this flag. This can be used to select particular ELF with -xelf option later. ```APIDOC ## cuobjdump --list-elf ### Description List all the ELF files available in the fatbin. Works with host executable/object/library and external fatbin. All other options are ignored with this flag. This can be used to select particular ELF with -xelf option later. ### Method CLI ### Endpoint cuobjdump --list-elf ### Parameters #### Command-Line Options - **--list-elf** (flag) - Required - List all ELF files. ### Request Example ``` $ cuobjdump --list-elf ``` ### Response #### Success Response Lists all ELF files available in the fatbin. ``` -------------------------------- ### cuobjdump a.out -xelf all - Extract all cubin files Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Extracts all cubin files from the host binary a.out using the -xelf all option. The output shows the extraction of four cubin files. ```bash $ cuobjdump a.out -xelf all Extracting ELF file 1: add_new.sm_100.cubin Extracting ELF file 2: add_new.sm_120.cubin Extracting ELF file 3: add_old.sm_100.cubin Extracting ELF file 4: add_old.sm_120.cubin ``` -------------------------------- ### Dump resource usage with cuobjdump -res-usage Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Use this command to dump common and per-function resource usage information for a cubin file. The output shows resource usage for common resources and each function, with REG, TEXTURE, SURFACE, and SAMPLER values as counts and other resources as bytes. ```bash $ cuobjdump test.cubin -res-usage Resource usage: Common: GLOBAL:56 CONSTANT[3]:28 Function calculate: REG:24 STACK:8 SHARED:0 LOCAL:0 CONSTANT[0]:472 CONSTANT[2]:24 TEXTURE:0 SURFACE:0 SAMPLER:0 Function mysurf_func: REG:38 STACK:8 SHARED:4 LOCAL:0 CONSTANT[0]:532 TEXTURE:8 SURFACE:7 SAMPLER:0 Function mytexsampler_func: REG:42 STACK:0 SHARED:0 LOCAL:0 CONSTANT[0]:472 TEXTURE:4 SURFACE:0 SAMPLER:1 ``` -------------------------------- ### cuobjdump --list-ptx Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html Lists all the PTX files available in the fatbin. Works with host executable/object/library and external fatbin. All other options are ignored with this flag. This can be used to select particular PTX with -xptx option later. ```APIDOC ## cuobjdump --list-ptx ### Description List all the PTX files available in the fatbin. Works with host executable/object/library and external fatbin. All other options are ignored with this flag. This can be used to select particular PTX with -xptx option later. ### Method CLI ### Endpoint cuobjdump --list-ptx ### Parameters #### Command-Line Options - **--list-ptx** (flag) - Required - List all PTX files. ### Request Example ``` $ cuobjdump --list-ptx ``` ### Response #### Success Response Lists all PTX files available in the fatbin. ``` -------------------------------- ### nvdisasm -g sample output with source line info Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Sample output from `nvdisasm -g` showing SASS instructions with source line annotations (e.g., `//## File ... line 25`). The output includes the kernel entry, register usage, and calls to `_Z3fooi` and `_Z3bari`. ```sass //--------------------- .text._Z6kernali -------------------------- .section .text._Z6kernali,"ax",@progbits .sectioninfo @"SHI_REGISTERS=24" .align 128 .global _Z6kernali .type _Z6kernali,@function .size _Z6kernali,(.L_4 - _Z6kernali) .other _Z6kernali,@"STO_CUDA_ENTRY STV_DEFAULT" _Z6kernali: .text._Z6kernali: /*0000*/ MOV R1, c[0x0][0x28] ; /*0010*/ NOP; //## File "/home/user/cuda/sample/sample.cu", line 25 /*0020*/ MOV R0, 0x160 ; /*0030*/ LDC R0, c[0x0][R0] ; /*0040*/ MOV R0, R0 ; /*0050*/ MOV R2, R0 ; //## File "/home/user/cuda/sample/sample.cu", line 26 /*0060*/ MOV R4, R2 ; /*0070*/ MOV R20, 32@lo((_Z6kernali + .L_1@srel)) ; /*0080*/ MOV R21, 32@hi((_Z6kernali + .L_1@srel)) ; /*0090*/ CALL.ABS.NOINC `(_Z3fooi) ; .L_1: /*00a0*/ MOV R0, R4 ; /*00b0*/ MOV R4, R2 ; /*00c0*/ MOV R2, R0 ; /*00d0*/ MOV R20, 32@lo((_Z6kernali + .L_2@srel)) ; /*00e0*/ MOV R21, 32@hi((_Z6kernali + .L_2@srel)) ; /*00f0*/ CALL.ABS.NOINC `(_Z3bari) ; .L_2: /*0100*/ MOV R4, R4 ; /*0110*/ IADD3 R4, R2, R4, RZ ; /*0120*/ MOV R2, 32@lo(arr) ; /*0130*/ MOV R3, 32@hi(arr) ; /*0140*/ MOV R2, R2 ; /*0150*/ MOV R3, R3 ; /*0160*/ ST.E.SYS [R2], R4 ; //## File "/home/user/cuda/sample/sample.cu", line 27 /*0170*/ ERRBAR ; /*0180*/ EXIT ; .L_3: /*0190*/ BRA `(.L_3); .L_4: ``` -------------------------------- ### nvdisasm basic usage Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Basic command-line usage for nvdisasm. It accepts a single input cubin file each time it is run. ```bash nvdisasm [options] ``` -------------------------------- ### Instruction Set Format for NVIDIA Ampere GPU and Ada Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Shows the general format for NVIDIA Ampere GPU and Ada instruction set instructions. Placeholders indicate the opcode, destination, and source operands. ```text (instruction) (destination) (source1), (source2) ... ``` -------------------------------- ### Generate Control Flow Graph PNG with nvdisasm and Graphviz Source: https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#blackwell-instruction-set Generates a PNG image (cfg.png) of the control flow of the cubin file a.cubin by piping nvdisasm output to Graphviz's dot command. ```bash nvdisasm -cfg a.cubin | dot -ocfg.png -Tpng ```