Files
project_6/cccl_upstream/thrust/thrust/mr/new.h
EngineX CI 56fd68e7dd [INFRA] Import NVIDIA/CCCL upstream as optimization reference library
CCCL (CUDA C++ Core Libraries) provides:
- CUB: device/block/warp-level GPU primitives (reduce, scan, sort, topk)
- Thrust: high-level parallel algorithms (transform_reduce, sort, scan)
- libcudacxx: CUDA C++ standard library (atomics, barriers, memory)
- cudax: experimental features (memory resources, allocators)
- Tuning policies: per-SM hardware-specific algorithm parameters

Competition optimization vectors mapped to CCCL:
- Output TPS (83% weight): warp_reduce, block_reduce, device_topk
- Input TPS (14% weight): device_scan, block_load, prefetch
- Cache TPS (3% weight): prefix caching strategy patterns
- Memory (0.9 util): pooled/cached/buddy allocators

Source: https://github.com/NVIDIA/cccl (shallow clone, HEAD only)
License: Apache-2.0
2026-07-30 09:35:51 +00:00

86 lines
3.1 KiB
C++

// SPDX-FileCopyrightText: Copyright (c) 2018, NVIDIA Corporation. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
/*! \file
* \brief Global operator new-based memory resource.
*/
#pragma once
#include <thrust/detail/config.h>
#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
# pragma GCC system_header
#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
# pragma clang system_header
#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
# pragma system_header
#endif // no system header
#include <thrust/mr/memory_resource.h>
THRUST_NAMESPACE_BEGIN
namespace mr
{
/** \addtogroup memory_resources Memory Resources
* \ingroup memory_management
* \{
*/
class new_delete_resource_base : public memory_resource<>
{
public:
void* do_allocate(std::size_t bytes, std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
{
#if __cpp_aligned_new >= 201606L
return ::operator new(bytes, std::align_val_t(alignment));
#else // ^^^ __cpp_aligned_new >= 201606L ^^^ / vvv __cpp_aligned_new < 201606L vvv
// allocate memory for bytes, plus potential alignment correction,
// plus store of the correction offset
void* p = ::operator new(bytes + alignment + sizeof(std::size_t));
std::size_t ptr_int = reinterpret_cast<std::size_t>(p);
// calculate the offset, i.e. how many bytes of correction was necessary
// to get an aligned pointer
std::size_t offset = (ptr_int % alignment) ? (alignment - ptr_int % alignment) : 0;
// calculate the return pointer
char* ptr = static_cast<char*>(p) + offset;
// store the offset right after the actually returned value
std::size_t* offset_store = reinterpret_cast<std::size_t*>(ptr + bytes);
*offset_store = offset;
return static_cast<void*>(ptr);
#endif // ^^^ __cpp_aligned_new < 201606L ^^^
}
void do_deallocate(void* p,
[[maybe_unused]] std::size_t bytes,
[[maybe_unused]] std::size_t alignment = THRUST_MR_DEFAULT_ALIGNMENT) override
{
#if __cpp_aligned_new >= 201606L
# if __cpp_sized_deallocation >= 201309L
::operator delete(p, bytes, std::align_val_t(alignment));
# else // ^^^ __cpp_sized_deallocation >= 201309L ^^^ / vvv __cpp_sized_deallocation < 201309L vvv
::operator delete(p, std::align_val_t(alignment));
# endif // ^^^ __cpp_sized_deallocation < 201309L ^^^
#else // ^^^ __cpp_aligned_new >= 201606L ^^^ / vvv __cpp_aligned_new < 201606L vvv
char* ptr = static_cast<char*>(p);
// calculate where the offset is stored
std::size_t* offset = reinterpret_cast<std::size_t*>(ptr + bytes);
// calculate the original pointer
p = static_cast<void*>(ptr - *offset);
::operator delete(p);
#endif // ^^^ __cpp_aligned_new < 201606L ^^^
}
};
/*! A memory resource that uses global operators new and delete to allocate and deallocate memory. Uses
* alignment-enabled overloads when available, otherwise uses regular overloads and implements alignment requirements by
* itself.
*/
class new_delete_resource final : public new_delete_resource_base
{};
/*! \} // memory_resources
*/
} // namespace mr
THRUST_NAMESPACE_END