File size: 5,271 Bytes
501e3f2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | /*
* Copyright 2018 NVIDIA Corporation
*
* 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.
*/
/*! \file
* \brief A type used by the pooling resource adaptors to fine-tune their
* behavior.
*/
#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 <cstddef>
#include <thrust/detail/integer_math.h>
#include <thrust/detail/config/memory_resource.h>
THRUST_NAMESPACE_BEGIN
namespace mr
{
/*! \addtogroup memory_resources Memory Resources
* \ingroup memory_management
* \{
*/
/*! A type used for configuring pooling resource adaptors, to fine-tune their behavior and parameters.
*/
struct pool_options
{
/*! The minimal number of blocks, i.e. pieces of memory handed off to the user from a pool of a given size, in a single
* chunk allocated from upstream.
*/
std::size_t min_blocks_per_chunk;
/*! The minimal number of bytes in a single chunk allocated from upstream.
*/
std::size_t min_bytes_per_chunk;
/*! The maximal number of blocks, i.e. pieces of memory handed off to the user from a pool of a given size, in a single
* chunk allocated from upstream.
*/
std::size_t max_blocks_per_chunk;
/*! The maximal number of bytes in a single chunk allocated from upstream.
*/
std::size_t max_bytes_per_chunk;
/*! The size of blocks in the smallest pool covered by the pool resource. All allocation requests below this size will
* be rounded up to this size.
*/
std::size_t smallest_block_size;
/*! The size of blocks in the largest pool covered by the pool resource. All allocation requests above this size will
* be considered oversized, allocated directly from upstream (and not from a pool), and cached only of \p cache_oversized
* is true.
*/
std::size_t largest_block_size;
/*! The alignment of all blocks in internal pools of the pool resource. All allocation requests above this alignment
* will be considered oversized, allocated directly from upstream (and not from a pool), and cached only of
* \p cache_oversized is true.
*/
std::size_t alignment;
/*! Decides whether oversized and overaligned blocks are cached for later use, or immediately return it to the upstream
* resource.
*/
bool cache_oversized;
/*! The size factor at which a cached allocation is considered too ridiculously oversized to use to fulfill an allocation
* request. For instance: the user requests an allocation of size 1024 bytes. A block of size 32 * 1024 bytes is
* cached. If \p cached_size_cutoff_factor is 32 or less, this block will be considered too big for that allocation
* request.
*/
std::size_t cached_size_cutoff_factor;
/*! The alignment factor at which a cached allocation is considered too ridiculously overaligned to use to fulfill an
* allocation request. For instance: the user requests an allocation aligned to 32 bytes. A block aligned to 1024 bytes
* is cached. If \p cached_size_cutoff_factor is 32 or less, this block will be considered too overaligned for that
* allocation request.
*/
std::size_t cached_alignment_cutoff_factor;
/*! Checks if the options are self-consistent.
*
* /returns true if the options are self-consitent, false otherwise.
*/
bool validate() const
{
if (!detail::is_power_of_2(smallest_block_size)) return false;
if (!detail::is_power_of_2(largest_block_size)) return false;
if (!detail::is_power_of_2(alignment)) return false;
if (max_bytes_per_chunk == 0 || max_blocks_per_chunk == 0) return false;
if (smallest_block_size == 0 || largest_block_size == 0) return false;
if (min_blocks_per_chunk > max_blocks_per_chunk) return false;
if (min_bytes_per_chunk > max_bytes_per_chunk) return false;
if (smallest_block_size > largest_block_size) return false;
if (min_blocks_per_chunk * smallest_block_size > max_bytes_per_chunk) return false;
if (min_blocks_per_chunk * largest_block_size > max_bytes_per_chunk) return false;
if (max_blocks_per_chunk * largest_block_size < min_bytes_per_chunk) return false;
if (max_blocks_per_chunk * smallest_block_size < min_bytes_per_chunk) return false;
if (alignment > smallest_block_size) return false;
return true;
}
};
/*! \} // memory_resources
*/
} // end mr
THRUST_NAMESPACE_END
|