[TRTLLM-17005][refactor] Component-local C++ Tests (Part 3)

cpp/cmake/templates/cuda_fatbin.ld

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* CUDA payloads can exceed 2 GiB. Place them before all host code so that
+ * code, unwind tables, the GOT, and code appended by BOLT remain close to
+ * each other. Keep .nvFatBinSegment (the registration wrappers containing
+ * pointers to the payloads) near host data.
+ * .dynsym precedes both code and unwind sections in GNU ld and LLD layouts.
+ */
+SECTIONS
+{
+    .nv_fatbin : { *(.nv_fatbin) }
+    __nv_relfatbin : { *(__nv_relfatbin) }
+}
+INSERT BEFORE .dynsym;

cpp/tensorrt_llm/CMakeLists.txt

@@ -259,6 +259,20 @@ set_target_properties(
   PROPERTIES CXX_STANDARD "20" CXX_STANDARD_REQUIRED "YES" CXX_EXTENSIONS "NO"
              LINK_FLAGS "${AS_NEEDED_FLAG} ${UNDEFINED_FLAG}")
 
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  # Keep host code, unwind tables, and the GOT within PC-relative addressing
+  # range, including after BOLT appends code, by placing CUDA payloads first.
+  set(CUDA_FATBIN_LINKER_SCRIPT
+      "${PROJECT_SOURCE_DIR}/cmake/templates/cuda_fatbin.ld")
+  foreach(target ${SHARED_TARGET} ${DECODER_SHARED_TARGET_0}
+                 ${DECODER_SHARED_TARGET_1})
+    target_link_options(${target} PRIVATE
+                        "LINKER:-T,${CUDA_FATBIN_LINKER_SCRIPT}")
+    set_property(TARGET ${target} APPEND
+                 PROPERTY LINK_DEPENDS "${CUDA_FATBIN_LINKER_SCRIPT}")
+  endforeach()
+endif()
+
 # Keep statically linked NVRTC symbols local so they cannot be interposed by a
 # dynamic NVRTC loaded elsewhere in the process.
 if(NOT WIN32 AND NOT NVRTC_DYNAMIC_LINKING)
@@ -270,15 +284,43 @@ endif()
 
 target_link_libraries(${SHARED_TARGET} PUBLIC ${TRTLLM_LINK_LIBS})
 
-target_link_libraries(
-  ${SHARED_TARGET}
-  PRIVATE
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,tllm_common_error,tllm_common_logging,tllm_common_cuda,tllm_executor_types,tllm_executor_serialization,tllm_runtime_memory,tllm_runtime_buffers,tllm_runtime_distributed,tllm_runtime_topology>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,tllm_common_environment,tllm_executor_values,tllm_executor_transfer_agent,tllm_kv_cache_host_memory,tllm_kv_cache,tllm_kv_cache_legacy,tllm_batch_scheduler,tllm_kernel_kv_cache_copy>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,${BATCH_MANAGER_TARGET}>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,${EXECUTOR_TARGET}>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,fp8_blockscale_gemm_src>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,${INTERNAL_CUTLASS_KERNELS_TARGET}>)
+foreach(
+  component
+  tllm_common_error
+  tllm_common_logging
+  tllm_common_cuda
+  tllm_executor_types
+  tllm_executor_serialization
+  tllm_runtime_memory
+  tllm_runtime_buffers
+  tllm_runtime_distributed
+  tllm_runtime_topology
+  tllm_common_cublas
+  tllm_common_environment
+  tllm_executor_values
+  tllm_executor_transfer_agent
+  tllm_kv_cache_host_memory
+  tllm_kv_cache
+  tllm_kv_cache_legacy
+  tllm_batch_scheduler
+  tllm_kernel_kv_cache_copy
+  ${BATCH_MANAGER_TARGET}
+  ${EXECUTOR_TARGET}
+  fp8_blockscale_gemm_src
+  ${INTERNAL_CUTLASS_KERNELS_TARGET})
+  target_link_libraries(${SHARED_TARGET}
+                        PRIVATE $<LINK_LIBRARY:WHOLE_ARCHIVE,${component}>)
+endforeach()
+
+foreach(component IN LISTS TLLM_KERNEL_COMPONENT_TARGETS)
+  target_link_libraries(${SHARED_TARGET}
+                        PRIVATE $<LINK_LIBRARY:WHOLE_ARCHIVE,${component}>)
+  set_property(TARGET ${SHARED_TARGET}
+               PROPERTY LINK_LIBRARY_OVERRIDE_${component} WHOLE_ARCHIVE)
+endforeach()
+
+set_property(TARGET ${SHARED_TARGET}
+             PROPERTY LINK_LIBRARY_OVERRIDE_tllm_common_cublas WHOLE_ARCHIVE)
 
 # Components also link each other normally; retain all component exports here.
 set_property(TARGET ${SHARED_TARGET}

cpp/tensorrt_llm/common/CMakeLists.txt

@@ -74,10 +74,21 @@ target_link_libraries(tllm_common_environment PUBLIC tllm::common_cuda)
 set_target_properties(tllm_common_environment
                       PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
+add_library(tllm_common_cublas STATIC cublasMMWrapper.cpp)
+add_library(tllm::common_cublas ALIAS tllm_common_cublas)
+target_link_libraries(tllm_common_cublas PUBLIC tllm::common_cuda CUDA::cublas
+                                                CUDA::cublasLt)
+target_compile_features(tllm_common_cublas PUBLIC cxx_std_20)
+set_target_properties(tllm_common_cublas PROPERTIES POSITION_INDEPENDENT_CODE
+                                                    ON)
+if(ENABLE_CUBLASLT_FP4_GEMM)
+  target_compile_definitions(tllm_common_cublas
+                             PRIVATE ENABLE_CUBLASLT_FP4_GEMM)
+endif()
+
 add_library(
   common_src OBJECT
   attentionOp.cpp
-  cublasMMWrapper.cpp
   cudaFp8Utils.cu
   cudaProfilerUtils.cpp
   mcastDevMemUtils.cpp
@@ -88,7 +99,8 @@ add_library(
 add_cuda_architectures(common_src 89)
 set_property(TARGET common_src PROPERTY POSITION_INDEPENDENT_CODE ON)
 set_property(TARGET common_src PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
-target_link_libraries(common_src PUBLIC trtllm_gen_fmha_interface)
+target_link_libraries(common_src PUBLIC trtllm_gen_fmha_interface
+                                        tllm::common_cublas)
 
 if(ENABLE_CUBLASLT_FP4_GEMM)
   target_compile_definitions(common_src PRIVATE ENABLE_CUBLASLT_FP4_GEMM)

cpp/tensorrt_llm/kernels/CMakeLists.txt

@@ -105,6 +105,11 @@ if(FAST_BUILD)
     STATUS "FAST_BUILD enabled for kernels: using -O1 for CUDA compilation")
 endif()
 
+include(kernelComponents.cmake)
+set(TLLM_KERNEL_COMPONENT_TARGETS
+    ${TLLM_KERNEL_COMPONENT_TARGETS}
+    PARENT_SCOPE)
+
 # Marlin NVFP4: build Ada/Hopper kernels and the dense W4A16/repack kernels used
 # on SM12x. Unsupported device passes emit empty kernel stubs.
 file(GLOB_RECURSE MARLIN_SRC "marlin/*.cu" "marlin/*.cpp")

cpp/tensorrt_llm/kernels/cutlass_kernels/CMakeLists.txt

@@ -163,15 +163,19 @@ file(GLOB_RECURSE MIXED_SRC_CU fpA_intB_gemm/*.cu)
 # Get the sources for MOE Grouped GEMM launchers. They live in the MoE domain
 # directory; the targets stay here, next to the CUTLASS instantiation generator
 # and the helpers (process_target, add_instantiations) they use.
-set(MOE_CUTLASS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../moe/cutlass)
+get_filename_component(MOE_CUTLASS_DIR
+                       "${CMAKE_CURRENT_SOURCE_DIR}/../moe/cutlass" ABSOLUTE)
 file(GLOB_RECURSE GROUPED_SRC_CPP ${MOE_CUTLASS_DIR}/*.cpp)
 file(GLOB_RECURSE GROUPED_SRC_CU ${MOE_CUTLASS_DIR}/*.cu)
 
 # Get the sources for FP8 Rowwise GEMM launchers
 file(GLOB_RECURSE FBGEMM_SRC_CU fp8_rowwise_gemm/*.cu)
 
 # Get the sources for FP8 Blockwise GEMM launchers
-file(GLOB_RECURSE FP8_BLOCKSCALE_GEMM_SRC_CU fp8_blockscale_gemm/*.cu)
+set(FP8_BLOCKSCALE_GEMM_SRC_CU
+    ${CMAKE_CURRENT_SOURCE_DIR}/fp8_blockscale_gemm/fp8_blockscale_gemm.cu
+    ${CMAKE_CURRENT_SOURCE_DIR}/fp8_blockscale_gemm/fp8_blockscale_quant_packed.cu
+)
 
 # Get the sources for FP4 GEMM launchers
 file(GLOB_RECURSE FP4_SRC_CU fp4_gemm/*.cu)
@@ -183,6 +187,15 @@ file(GLOB_RECURSE ARGEMM_SRC_CU allreduce_gemm/*.cu)
 file(GLOB_RECURSE SRC_CPP *.cpp)
 file(GLOB_RECURSE SRC_CU *.cu)
 set(ALL_SRCS ${SRC_CPP};${SRC_CU})
+list(
+  REMOVE_ITEM
+  ALL_SRCS
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_bf16.cu"
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_fp16.cu"
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_fp32.cu"
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_int32.cu")
+list(REMOVE_ITEM ALL_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/cutlass_heuristic.cpp"
+     "${CMAKE_CURRENT_SOURCE_DIR}/cutlass_preprocessors.cpp")
 list(FILTER ALL_SRCS EXCLUDE REGEX "fpA_intB_gemm/.*")
 list(FILTER ALL_SRCS EXCLUDE REGEX "fp8_rowwise_gemm/.*")
 list(FILTER ALL_SRCS EXCLUDE REGEX "fp8_blockscale_gemm/.*")
@@ -205,9 +218,20 @@ message(VERBOSE "FP4 srcs ${FP4_SRC_CU} ${FP4_CU_INSTANTIATIONS}")
 message(VERBOSE "ARgemm srcs ${ARGEMM_SRC_CU}")
 message(VERBOSE "All srcs ${ALL_SRCS}")
 
-add_library(cutlass_src STATIC ${ALL_SRCS})
+if(ALL_SRCS)
+  add_library(cutlass_src STATIC ${ALL_SRCS})
+  target_link_libraries(cutlass_src PUBLIC tllm::kernel_gemm_utilities
+                                           tllm::kernel_int8_gemm)
+else()
+  add_library(cutlass_src INTERFACE)
+  target_link_libraries(cutlass_src INTERFACE tllm::kernel_gemm_utilities
+                                              tllm::kernel_int8_gemm)
+endif()
 
 add_library(fpA_intB_gemm_src STATIC ${MIXED_SRC_CPP} ${MIXED_SRC_CU})
+add_library(tllm::kernel_weight_only_gemm ALIAS fpA_intB_gemm_src)
+target_link_libraries(fpA_intB_gemm_src PUBLIC tllm::kernel_gemm_utilities
+                                               tllm::common_environment)
 add_cuda_architectures(fpA_intB_gemm_src 89)
 add_instantiations(fpA_intB_gemm_src ${INSTANTIATION_GENERATION_DIR}/gemm)
 
@@ -217,11 +241,18 @@ set_cuda_architectures(fb_gemm_src ${CUTLASS_COMMON_ARCHS})
 # ${INSTANTIATION_GENERATION_DIR}/fp8_rowwise_gemm)
 
 add_library(fp8_blockscale_gemm_src STATIC ${FP8_BLOCKSCALE_GEMM_SRC_CU})
+add_library(tllm::kernel_fp8_block_scale_gemm ALIAS fp8_blockscale_gemm_src)
+target_link_libraries(
+  fp8_blockscale_gemm_src
+  PUBLIC tllm::kernel_gemm_utilities tllm::common_environment CUDA::cuda_driver
+         ${NVRTC_LIB} ${NVRTC_BUILTINS_LIB})
 set_cuda_architectures(fp8_blockscale_gemm_src ${CUTLASS_COMMON_ARCHS})
 
 set(GEMM_SWIGLU_SM90_SRC_CU
     ${CMAKE_CURRENT_SOURCE_DIR}/fused_gated_gemm/gemm_swiglu_e4m3.cu)
 add_library(gemm_swiglu_sm90_src STATIC ${GEMM_SWIGLU_SM90_SRC_CU})
+add_library(tllm::kernel_gated_gemm ALIAS gemm_swiglu_sm90_src)
+target_link_libraries(gemm_swiglu_sm90_src PUBLIC tllm::kernel_gemm_utilities)
 set_cuda_architectures(gemm_swiglu_sm90_src 90)
 
 if(USING_OSS_CUTLASS_LOW_LATENCY_GEMM)
@@ -241,7 +272,30 @@ if(USING_OSS_CUTLASS_FP4_GEMM)
 endif()
 
 if(USING_OSS_CUTLASS_MOE_GEMM)
-  file(GLOB MOE_GEMM_SRC_CU "${MOE_CUTLASS_DIR}/*.cu")
+  set(MOE_GEMM_SRC_CU
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_bf16.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_fp8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_uint4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_uint8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_fp16.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_uint4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_uint8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp32_fp32.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp4_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp8_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp8_fp8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp8_uint4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_tma_warp_specialized_input.cu"
+      "${MOE_CUTLASS_DIR}/moe_kernels.cu"
+      "${MOE_CUTLASS_DIR}/moe_lora_pointer_expand.cu"
+      "${MOE_CUTLASS_DIR}/moe_lora_problem_builder.cu"
+      "${MOE_CUTLASS_DIR}/moe_lora_slot_expand.cu")
+  list(
+    REMOVE_ITEM MOE_GEMM_SRC_CU "${MOE_CUTLASS_DIR}/moe_lora_pointer_expand.cu"
+    "${MOE_CUTLASS_DIR}/moe_lora_problem_builder.cu"
+    "${MOE_CUTLASS_DIR}/moe_lora_slot_expand.cu")
   set(MOE_GEMM_SRC_CU_LAUNCHER ${MOE_GEMM_SRC_CU})
   list(FILTER MOE_GEMM_SRC_CU_LAUNCHER EXCLUDE REGEX ".*moe_gemm_kernels_.*")
   list(FILTER MOE_GEMM_SRC_CU INCLUDE REGEX ".*moe_gemm_kernels_.*")
@@ -258,6 +312,12 @@ if(USING_OSS_CUTLASS_MOE_GEMM)
   list(FILTER MOE_GEMM_SRC_CU EXCLUDE REGEX ".*fp8.*")
 
   add_library(moe_gemm_src STATIC ${MOE_GEMM_SRC_CU} ${GROUPED_SRC_CPP})
+  add_library(tllm::kernel_moe ALIAS moe_gemm_src)
+  target_link_libraries(
+    moe_gemm_src
+    PUBLIC tllm::kernel_gemm_utilities tllm::kernel_fp8_block_scale_gemm
+           tllm::kernel_lora tllm::kernel_pre_quant_scale
+           tllm::common_environment)
 
   add_library(_moe_gemm_launcher OBJECT ${MOE_GEMM_SRC_CU_LAUNCHER})
   add_cuda_architectures(_moe_gemm_launcher 89)
@@ -276,8 +336,8 @@ if(USING_OSS_CUTLASS_MOE_GEMM)
 
   add_instantiations(moe_gemm_src ${INSTANTIATION_GENERATION_DIR}/gemm_grouped)
   target_link_libraries(
-    moe_gemm_src PRIVATE _moe_gemm_launcher _moe_gemm_hopper_fp4 _moe_gemm_fp4
-                         _moe_gemm_fp8)
+    moe_gemm_src PRIVATE tllm::kernel_moe_lora _moe_gemm_launcher
+                         _moe_gemm_hopper_fp4 _moe_gemm_fp4 _moe_gemm_fp8)
   target_include_directories(
     moe_gemm_src
     PUBLIC ${PROJECT_SOURCE_DIR}/tensorrt_llm/cutlass_extensions/include)

cpp/tensorrt_llm/kernels/decoderMaskedMultiheadAttention/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION &
+# SPDX-FileCopyrightText: Copyright (c) 1993-2026 NVIDIA CORPORATION &
 # AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not
@@ -40,11 +40,6 @@ foreach(HEAD ${basic_heads})
   list(APPEND SRC_CU ${HEAD_SRCS})
 endforeach()
 
-# Cascade attention kernel. Compiled together with the basic heads so it lives
-# in the same shared library as the MMHA dispatcher that calls into it. Uses Dh
-# in {64, 128}.
-list(APPEND SRC_CU ${CMAKE_CURRENT_SOURCE_DIR}/cascadeAttentionKernel.cu)
-
 # skip mmha 48, 80, 96, 104, 112, 144, 160, 192 and 224 for fast build
 if(FAST_BUILD)
   set(extra_heads 256)
@@ -82,9 +77,18 @@ if(NOT WIN32)
                PROPERTY POSITION_INDEPENDENT_CODE ON)
   set_property(TARGET ${DECODER_SHARED_TARGET_1}
                PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+  foreach(target ${DECODER_SHARED_TARGET_0} ${DECODER_SHARED_TARGET_1})
+    target_link_libraries(${target} PUBLIC tllm::common_environment
+                                           tllm::kernel_cascade_attention)
+  endforeach()
 else()
-  target_sources(decoder_attention_src PRIVATE ${SRC_CPP} ${SRC_CU}
-                                               ${SRC_CU_EXTRA})
+  target_sources(decoder_attention_src PRIVATE ${SRC_CPP})
+  add_library(tllm_mmha STATIC ${SRC_CU} ${SRC_CU_EXTRA})
+  target_link_libraries(tllm_mmha PUBLIC tllm::common_environment
+                                         tllm::kernel_cascade_attention)
+  set_target_properties(tllm_mmha PROPERTIES POSITION_INDEPENDENT_CODE ON
+                                             CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+  target_link_libraries(decoder_attention_src PUBLIC tllm_mmha)
 endif()
 
 target_link_libraries(decoder_attention_src PUBLIC nvrtc_wrapper_src