ExecutorResourcePool keeps track of available compute and memory resources and can be queried to get the min and max resources grantable (embodied in a ResourceGrant) for a request, given a ResourceRequest. More...

#include <ExecutorResourcePool.h>

Public Member Functions
	ExecutorResourcePool (const std::vector< std::pair< ResourceType, size_t >> &total_resources, const std::vector< ConcurrentResourceGrantPolicy > &concurrent_resource_grant_policies, const std::vector< ResourceGrantPolicy > &max_per_request_resource_grant_policies)

void	log_parameters () const

std::vector< ResourceRequestGrant >	calc_static_resource_grant_ranges_for_request (const std::vector< ResourceRequest > &resource_requests) const

std::pair< ResourceGrant, ResourceGrant >	calc_min_max_resource_grants_for_request (const RequestInfo &resource_request) const
	Given the provided resource_request, statically calculate the minimum and maximum grantable resources for that request. Note that the max resource grant may be less that requested by the query. More...

bool	can_currently_satisfy_request (const ResourceGrant &min_resource_grant, const ChunkRequestInfo &chunk_request_info) const

std::pair< bool, ResourceGrant >	determine_dynamic_resource_grant (const ResourceGrant &min_resource_grant, const ResourceGrant &max_resource_grant, const ChunkRequestInfo &chunk_request_info, const double max_request_backoff_ratio) const
	Determines the actual resource grant to give a query (which will be somewhere between the provided min_resource_grant and max_resource_grant, unless it is determined that the request cannot be currently satisfied). More...

void	allocate_resources (const ResourceGrant &resource_grant, const ChunkRequestInfo &chunk_request_info)
	Given a resource grant (assumed to be computed in determine_dynamic_resource_grant), actually allocate (reserve) the resources in the pool so other requestors (queries) cannot use those resources until returned to the pool. More...

void	deallocate_resources (const ResourceGrant &resource_grant, const ChunkRequestInfo &chunk_request_info)
	Deallocates resources granted to a requestor such that they can be used for other requests. More...

std::pair< size_t, size_t >	get_resource_info (const ResourceType resource_type) const
	Returns the allocated and total available amount of the resource specified. More...

ResourcePoolInfo	get_resource_info () const
	Returns a struct detailing the allocated and total available resources of each type tracked in ExecutorResourcePool. More...

void	set_resource (const ResourceType resource_type, const size_t resource_quantity)
	Sets the quantity of resource_type to resource_quantity. If pool has outstanding requests, will throw. Responsibility of allowing the pool to empty and preventing concurrent requests while this operation is running is left to the caller (in particular, ExecutorResourceMgr::set_resource pauses the process queue, which waits until all executing requests are finished before yielding to the caller, before calling this method). More...

ConcurrentResourceGrantPolicy	get_concurrent_resource_grant_policy (const ResourceType resource_type) const

const ResourceGrantPolicy &	get_max_resource_grant_per_request_policy (const ResourceSubtype resource_subtype) const

void	set_concurrent_resource_grant_policy (const ConcurrentResourceGrantPolicy &concurrent_resource_grant_policy)
	Resets the concurrent resource grant policy object, which specifies a ResourceType as well as normal and oversubscription concurrency policies. If pool has outstanding requests, will throw. Responsibility of allowing the pool to empty and preventing concurrent requests while this operation is running is left to the caller (in particular, ExecutorResourceMgr::set_concurent_resource_grant_policy pauses the process queue, which waits until all executing requests are finished before yielding to the caller, before calling this method). More...

Private Member Functions
void	init (const std::vector< std::pair< ResourceType, size_t >> &total_resources, const std::vector< ConcurrentResourceGrantPolicy > &concurrent_resource_grant_policies, const std::vector< ResourceGrantPolicy > &max_per_request_resource_grant_policies)

void	init_concurrency_policies ()

void	init_max_resource_grants_per_requests ()

void	throw_insufficient_resource_error (const ResourceSubtype resource_subtype, const size_t min_resource_requested) const

size_t	calc_max_resource_grant_for_request (const size_t requested_resource_quantity, const size_t min_requested_resource_quantity, const size_t max_grantable_resource_quantity) const

std::pair< size_t, size_t >	calc_min_dependent_resource_grant_for_request (const size_t min_requested_dependent_resource_quantity, const size_t min_requested_independent_resource_quantity, const size_t dependent_to_independent_resource_ratio) const

std::pair< size_t, size_t >	calc_max_dependent_resource_grant_for_request (const size_t requested_dependent_resource_quantity, const size_t min_requested_dependent_resource_quantity, const size_t max_grantable_dependent_resource_quantity, const size_t min_requested_independent_resource_quantity, const size_t max_grantable_independent_resource_quantity, const size_t dependent_to_independent_resource_ratio) const

bool	check_request_against_global_policy (const size_t resource_total, const size_t resource_allocated, const ConcurrentResourceGrantPolicy &concurrent_resource_grant_policy) const

bool	check_request_against_policy (const size_t resource_request, const size_t resource_total, const size_t resource_allocated, const size_t global_outstanding_requests, const ConcurrentResourceGrantPolicy &concurrent_resource_grant_policy) const

bool	can_currently_satisfy_request_impl (const ResourceGrant &min_resource_grant, const ChunkRequestInfo &chunk_request_info) const

bool	can_currently_satisfy_chunk_request (const ResourceGrant &min_resource_grant, const ChunkRequestInfo &chunk_request_info) const

ChunkRequestInfo	get_requested_chunks_not_in_pool (const ChunkRequestInfo &chunk_request_info) const

size_t	get_chunk_bytes_not_in_pool (const ChunkRequestInfo &chunk_request_info) const

void	add_chunk_requests_to_allocated_pool (const ResourceGrant &resource_grant, const ChunkRequestInfo &chunk_request_info)

void	remove_chunk_requests_from_allocated_pool (const ResourceGrant &resource_grant, const ChunkRequestInfo &chunk_request_info)

size_t	determine_dynamic_single_resource_grant (const size_t min_resource_requested, const size_t max_resource_requested, const size_t resource_allocated, const size_t total_resource, const double max_request_backoff_ratio) const

void	sanity_check_requests_against_allocations () const

size_t	get_total_allocated_buffer_pool_mem_for_level (const ExecutorDeviceType memory_pool_type) const

bool	is_resource_valid (const ResourceType resource_type) const

size_t	get_total_resource (const ResourceType resource_type) const

size_t	get_allocated_resource_of_subtype (const ResourceSubtype resource_subtype) const

size_t	get_allocated_resource_of_type (const ResourceType resource_type) const

size_t	get_max_resource_grant_per_request (const ResourceSubtype resource_subtype) const

size_t	get_total_per_resource_num_requests (const ResourceType resource_type) const

size_t	increment_total_per_resource_num_requests (const ResourceType resource_type)

size_t	decrement_total_per_resource_num_requests (const ResourceType resource_type)

size_t	get_outstanding_per_resource_num_requests (const ResourceType resource_type) const

size_t	increment_outstanding_per_resource_num_requests (const ResourceType resource_type)

size_t	decrement_outstanding_per_resource_num_requests (const ResourceType resource_type)

Private Attributes
std::array< size_t, ResourceTypeSize >	total_resources_ {}

std::array< bool, ResourceTypeSize >	resource_type_validity_

std::array< size_t, ResourceSubtypeSize >	allocated_resources_ {}

std::array < ResourceGrantPolicy, ResourceSubtypeSize >	max_resource_grants_per_request_policies_ {}

std::array< size_t, ResourceSubtypeSize >	max_resource_grants_per_request_ {}

std::array < ConcurrentResourceGrantPolicy, ResourceTypeSize >	concurrent_resource_grant_policies_

size_t	total_num_requests_ {0}

size_t	outstanding_num_requests_ {0}

std::array< size_t, ResourceTypeSize >	total_per_resource_num_requests_ {}

std::array< size_t, ResourceTypeSize >	outstanding_per_resource_num_requests_ {}

BufferPoolChunkMap	allocated_cpu_buffer_pool_chunks_

BufferPoolChunkMap	allocated_gpu_buffer_pool_chunks_

const bool	sanity_check_pool_state_on_deallocations_ {false}

std::shared_mutex	resource_mutex_

Detailed Description

ExecutorResourcePool keeps track of available compute and memory resources and can be queried to get the min and max resources grantable (embodied in a ResourceGrant) for a request, given a ResourceRequest.

ExecutorResourcePool keeps track of logical resources available to the executor, categorized and typed by the ResourceType enum. Current valid categories of ResourceType include CPU_SLOTS, GPU_SLOTS, CPU_RESULT_MEM, CPU_BUFFER_POOL_MEM, and GPU_BUFFER_POOL_MEM. Furthermore, a ResourceSubtype enum is used to represent more granular sub-categories of the above. Namely, there exists ResourceSubtype PINNED_CPU_BUFFER_POOL_MEM and PINNED_GPU_BUFFER_POOL_MEM to represent non-pageable memory (specifcally for kernel results), and PAGEABLE_CPU_BUFFER_POOL_MEM and PAGEABLE_GPU_BUFFER_POOL_MEM to represent data that could be evicted as neccessary.

Currently, a singleton ExecutorResourcePool is managed by ExecutorResourceMgr and is initialized by the latter in the ExecutorResourceMgr constructor. Various parameters driving behavior of ExecutorResourcePool are passed to its constructor, comprising the total resources available in the pool in each of the above categories, policies around concurrent requests to the pool for each of the resources (embodied in a vector of ConcurrentResourceGrantPolicy), and policies around limits to individual resource grants (embodied in a vector of ResourceGrantPolicy).

Generally for a given resource request, the following lifecycle is prescribed, as can be seen in the various invocations of ExecutorResourcePool methods by ExecutorResourceMgr:

call_min_max_resource_grants_for_request: Get min and max possible resource grant, given a resource_request. If it is determined to be impossible to grant even the minimum requests specified in resource_request, this will throw an error.
determine_dynamic_resource_grant: Given the min and max possible resource grants determined from #1, the ExecutorResourcePool calculates an actual grant to give a query based on current resource availability in the pool.
allocate_resources: Allocate the actual resource grant computed in #2 from the ExecutorResourcePool, marking the resources as used/allocated so they cannot be used by other queries/requestors until deallocated
deallocate_resources: Ultimately invoked from the destructor of the resource handle given to the executing thread, this returns the allocated resources to the pool for use by other queries.

Definition at line 237 of file ExecutorResourcePool.h.

Constructor & Destructor Documentation

ExecutorResourceMgr_Namespace::ExecutorResourcePool::ExecutorResourcePool	(	const std::vector< std::pair< ResourceType, size_t >> &	total_resources,
		const std::vector< ConcurrentResourceGrantPolicy > &	concurrent_resource_grant_policies,
		const std::vector< ResourceGrantPolicy > &	max_per_request_resource_grant_policies
	)

Definition at line 48 of file ExecutorResourcePool.cpp.

References init(), and log_parameters().

                                                                                    {
   init(total_resources,
        concurrent_resource_grant_policies,
        max_per_request_resource_grant_policies);
   log_parameters();
 }

Here is the call graph for this function:

Member Function Documentation

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::add_chunk_requests_to_allocated_pool	(	const ResourceGrant &	resource_grant,
		const ChunkRequestInfo &	chunk_request_info
	)

private

Definition at line 714 of file ExecutorResourcePool.cpp.

Referenced by allocate_resources().

                                                 {
   // Expects lock on resource_mutex_ already taken
 
   if (resource_grant.buffer_mem_gated_per_slot) {
     CHECK(chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU);
     CHECK_LE(get_total_allocated_buffer_pool_mem_for_level(
                  chunk_request_info.device_memory_pool_type) +
                  resource_grant.buffer_mem_for_given_slots,
              get_total_resource(ResourceType::CPU_BUFFER_POOL_MEM));
     allocated_resources_[static_cast<size_t>(
         ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM)] +=
         resource_grant.buffer_mem_for_given_slots;
 
     const std::string& pool_level_string =
         chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU ? "CPU"
                                                                               : "GPU";
     LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                   << " allocated_temp chunk addition: "
                   << format_num_bytes(resource_grant.buffer_mem_for_given_slots);
     LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                   << " pool state: Transient Allocations: "
                   << format_num_bytes(get_allocated_resource_of_subtype(
                          ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM))
                   << " Total Allocations: "
                   << format_num_bytes(get_total_allocated_buffer_pool_mem_for_level(
                          chunk_request_info.device_memory_pool_type));
     return;
   }
 
   BufferPoolChunkMap& chunk_map_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? allocated_cpu_buffer_pool_chunks_
           : allocated_gpu_buffer_pool_chunks_;
   size_t& pinned_buffer_mem_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? allocated_resources_[static_cast<size_t>(
                 ResourceSubtype::PINNED_CPU_BUFFER_POOL_MEM)]
           : allocated_resources_[static_cast<size_t>(
                 ResourceSubtype::PINNED_GPU_BUFFER_POOL_MEM)];
   const size_t total_buffer_mem_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? get_total_resource(ResourceType::CPU_BUFFER_POOL_MEM)
           : get_total_resource(ResourceType::GPU_BUFFER_POOL_MEM);
 
   // Following variables are for logging
   const size_t pre_pinned_chunks_for_memory_level = chunk_map_for_memory_level.size();
   const size_t pre_pinned_buffer_mem_for_memory_level =
       pinned_buffer_mem_for_memory_level;
 
   for (const auto& requested_chunk : chunk_request_info.chunks_with_byte_sizes) {
     auto chunk_itr = chunk_map_for_memory_level.find(requested_chunk.first);
     if (chunk_itr == chunk_map_for_memory_level.end()) {
       pinned_buffer_mem_for_memory_level += requested_chunk.second;
       chunk_map_for_memory_level.insert(
           std::make_pair(requested_chunk.first,
                          std::make_pair(size_t(1) /* initial reference count */,
                                         requested_chunk.second)));
     } else {
       if (requested_chunk.second > chunk_itr->second.second) {
         pinned_buffer_mem_for_memory_level +=
             requested_chunk.second - chunk_itr->second.second;
         chunk_itr->second.second = requested_chunk.second;
       }
       chunk_itr->second.first += 1;  // Add reference count
     }
   }
   const size_t post_pinned_chunks_for_memory_level = chunk_map_for_memory_level.size();
   const size_t net_new_allocated_chunks =
       post_pinned_chunks_for_memory_level - pre_pinned_chunks_for_memory_level;
   const size_t net_new_allocated_memory =
       pinned_buffer_mem_for_memory_level - pre_pinned_buffer_mem_for_memory_level;
 
   const std::string& pool_level_string =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU ? "CPU"
                                                                             : "GPU";
   LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                 << " chunk allocation: " << chunk_request_info.num_chunks << " chunks | "
                 << format_num_bytes(chunk_request_info.total_bytes);
   LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                 << " pool delta: " << net_new_allocated_chunks << " chunks added | "
                 << format_num_bytes(net_new_allocated_memory);
   LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                 << " pool state: " << post_pinned_chunks_for_memory_level << " chunks | "
                 << format_num_bytes(get_total_allocated_buffer_pool_mem_for_level(
                        chunk_request_info.device_memory_pool_type));
 
   if (ENABLE_DEBUG_PRINTING) {
     debug_print("After chunk allocation: ",
                 format_num_bytes(pinned_buffer_mem_for_memory_level),
                 " of ",
                 format_num_bytes(total_buffer_mem_for_memory_level),
                 ", with ",
                 chunk_map_for_memory_level.size(),
                 " chunks.");
   }
   CHECK_LE(pinned_buffer_mem_for_memory_level, total_buffer_mem_for_memory_level);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::allocate_resources	(	const ResourceGrant &	resource_grant,
		const ChunkRequestInfo &	chunk_request_info
	)

Given a resource grant (assumed to be computed in determine_dynamic_resource_grant), actually allocate (reserve) the resources in the pool so other requestors (queries) cannot use those resources until returned to the pool.

Note that the chunk requests do not and should not neccessarily match the state of the BufferMgrs (where evictions can happen etc), but are just used to keep track of what chunks are pledged for running queries. In the future we may try to get all of this info from the BufferMgr directly, but would need to add a layer of state there that would keep track of both what is currently allocated and what is pledged to queries. For now, this effort was not deemed worth the complexity and risk it would introduce.

Parameters

resource_grant	- Granted resource_grant, assumed to be determined previously in determine_dynamic_resource_grant
chunk_request_info	- The DataMgr chunk keys and other associated info needed by this query. The ExecutorResourcePool must keep track of chunks that are in the pool so it can properly determine whether queries can execute (given chunks can be shared resources across requestors/queries).

Definition at line 1022 of file ExecutorResourcePool.cpp.

Referenced by ExecutorResourceMgr_Namespace::ExecutorResourceMgr::process_queue_loop().

                                                 {
   std::unique_lock<std::shared_mutex> resource_write_lock(resource_mutex_);
 
   // Caller (ExecutorResourceMgr) should never request resource allocation for a request
   // it knows cannot be granted, however use below as a sanity check Use unlocked
   // internal method as we already hold lock above
   const bool can_satisfy_request =
       can_currently_satisfy_request_impl(resource_grant, chunk_request_info);
   CHECK(can_satisfy_request);
 
   allocated_resources_[static_cast<size_t>(ResourceSubtype::CPU_SLOTS)] +=
       resource_grant.cpu_slots;
   allocated_resources_[static_cast<size_t>(ResourceSubtype::GPU_SLOTS)] +=
       resource_grant.gpu_slots;
   allocated_resources_[static_cast<size_t>(ResourceSubtype::CPU_RESULT_MEM)] +=
       resource_grant.cpu_result_mem;
 
   total_num_requests_++;
   outstanding_num_requests_++;
   if (resource_grant.cpu_slots > 0) {
     increment_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS);
     increment_total_per_resource_num_requests(ResourceType::CPU_SLOTS);
   }
   if (resource_grant.gpu_slots > 0) {
     increment_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS);
     increment_total_per_resource_num_requests(ResourceType::GPU_SLOTS);
   }
   if (resource_grant.cpu_result_mem > 0) {
     increment_outstanding_per_resource_num_requests(ResourceType::CPU_RESULT_MEM);
     increment_total_per_resource_num_requests(ResourceType::CPU_RESULT_MEM);
   }
   if (chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU) {
     if (resource_grant.buffer_mem_gated_per_slot ||
         (chunk_request_info.num_chunks > 0 && chunk_request_info.total_bytes > 0)) {
       increment_outstanding_per_resource_num_requests(ResourceType::CPU_BUFFER_POOL_MEM);
       increment_total_per_resource_num_requests(ResourceType::CPU_BUFFER_POOL_MEM);
     }
   } else if (chunk_request_info.device_memory_pool_type == ExecutorDeviceType::GPU) {
     if (resource_grant.buffer_mem_gated_per_slot ||
         (chunk_request_info.num_chunks > 0 && chunk_request_info.total_bytes > 0)) {
       increment_outstanding_per_resource_num_requests(ResourceType::GPU_BUFFER_POOL_MEM);
       increment_total_per_resource_num_requests(ResourceType::GPU_BUFFER_POOL_MEM);
     }
   }
 
   LOG(EXECUTOR) << "ExecutorResourcePool allocation: " << outstanding_num_requests_
                 << " requests ("
                 << get_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS)
                 << " CPU | "
                 << get_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS)
                 << " GPU)";
   LOG(EXECUTOR) << "ExecutorResourcePool state: CPU slots: "
                 << get_allocated_resource_of_type(ResourceType::CPU_SLOTS) << " of "
                 << get_total_resource(ResourceType::CPU_SLOTS) << " | GPU slots: "
                 << get_allocated_resource_of_type(ResourceType::GPU_SLOTS) << " of "
                 << get_total_resource(ResourceType::GPU_SLOTS) << " CPU result mem: "
                 << format_num_bytes(
                        get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM))
                 << " of "
                 << format_num_bytes(get_total_resource(ResourceType::CPU_RESULT_MEM));
   add_chunk_requests_to_allocated_pool(resource_grant, chunk_request_info);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< size_t, size_t > ExecutorResourceMgr_Namespace::ExecutorResourcePool::calc_max_dependent_resource_grant_for_request	(	const size_t	requested_dependent_resource_quantity,
		const size_t	min_requested_dependent_resource_quantity,
		const size_t	max_grantable_dependent_resource_quantity,
		const size_t	min_requested_independent_resource_quantity,
		const size_t	max_grantable_independent_resource_quantity,
		const size_t	dependent_to_independent_resource_ratio
	)		const

private

Definition at line 266 of file ExecutorResourcePool.cpp.

References calc_min_dependent_resource_grant_for_request(), CHECK_GE, and CHECK_LE.

Referenced by calc_min_max_resource_grants_for_request(), and determine_dynamic_resource_grant().

                                                                 {
   CHECK_LE(min_requested_dependent_resource_quantity,
            requested_dependent_resource_quantity);
   CHECK_LE(min_requested_independent_resource_quantity,
            max_grantable_independent_resource_quantity);
 
   if (requested_dependent_resource_quantity <=
       max_grantable_dependent_resource_quantity) {
     // Dependent resource request falls under max grantable limit, grant requested
     // resource
     return std::make_pair(requested_dependent_resource_quantity,
                           max_grantable_independent_resource_quantity);
   }
   // First member of pair returned is min resource grant, second is min dependent
   // resource grant
   const auto adjusted_min_dependent_and_independent_resource_grant =
       calc_min_dependent_resource_grant_for_request(
           min_requested_dependent_resource_quantity,
           min_requested_independent_resource_quantity,
           dependent_to_independent_resource_ratio);
 
   if (adjusted_min_dependent_and_independent_resource_grant.first >
       max_grantable_dependent_resource_quantity) {
     // If here the min grantable dependent resource is greater than what was to provided
     // to the function as grantable of the dependent resource
     return std::make_pair(static_cast<size_t>(0), static_cast<size_t>(0));
   }
 
   const size_t adjusted_max_independent_resource_quantity = std::min(
       max_grantable_dependent_resource_quantity / dependent_to_independent_resource_ratio,
       max_grantable_independent_resource_quantity);
 
   CHECK_GE(adjusted_max_independent_resource_quantity,
            adjusted_min_dependent_and_independent_resource_grant.second);
 
   const size_t granted_dependent_resource_quantity =
       dependent_to_independent_resource_ratio *
       adjusted_max_independent_resource_quantity;
   return std::make_pair(granted_dependent_resource_quantity,
                         adjusted_max_independent_resource_quantity);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::calc_max_resource_grant_for_request	(	const size_t	requested_resource_quantity,
		const size_t	min_requested_resource_quantity,
		const size_t	max_grantable_resource_quantity
	)		const

private

Definition at line 235 of file ExecutorResourcePool.cpp.

Referenced by calc_min_max_resource_grants_for_request(), and calc_static_resource_grant_ranges_for_request().

                                                         {
   if (requested_resource_quantity <= max_grantable_resource_quantity) {
     return requested_resource_quantity;
   }
   if (min_requested_resource_quantity <= max_grantable_resource_quantity) {
     return max_grantable_resource_quantity;
   }
   return static_cast<size_t>(0);
 }

Here is the caller graph for this function:

std::pair< size_t, size_t > ExecutorResourceMgr_Namespace::ExecutorResourcePool::calc_min_dependent_resource_grant_for_request	(	const size_t	min_requested_dependent_resource_quantity,
		const size_t	min_requested_independent_resource_quantity,
		const size_t	dependent_to_independent_resource_ratio
	)		const

private

Definition at line 249 of file ExecutorResourcePool.cpp.

Referenced by calc_max_dependent_resource_grant_for_request(), and calc_min_max_resource_grants_for_request().

                                                                 {
   const size_t adjusted_min_independent_resource_quantity =
       std::max(static_cast<size_t>(
                    ceil(static_cast<double>(min_requested_dependent_resource_quantity) /
                         dependent_to_independent_resource_ratio)),
                min_requested_independent_resource_quantity);
   const size_t adjusted_min_dependent_resource_quantity =
       adjusted_min_independent_resource_quantity *
       dependent_to_independent_resource_ratio;
   return std::make_pair(adjusted_min_dependent_resource_quantity,
                         adjusted_min_independent_resource_quantity);
 }

Here is the caller graph for this function:

std::pair< ResourceGrant, ResourceGrant > ExecutorResourceMgr_Namespace::ExecutorResourcePool::calc_min_max_resource_grants_for_request ( const RequestInfo & resource_request ) const

Given the provided resource_request, statically calculate the minimum and maximum grantable resources for that request. Note that the max resource grant may be less that requested by the query.

Note that this method only looks at static total available resources as well as the ideal and minimum resources requested (in resource_request) to determine the max grants, and does not evaluate the current state of resource use in the pool. That is done in a later call, detrmine_dynamic_resource_grant.

Parameters

resource_request - Details the resources a query would like to have as well as the minimum resources it can run with

Returns: std::pair<ResourceGrant, ResourceGrant> - A pair of the minimum and maximum grantable resources that could be potentially granted for this request,

Definition at line 365 of file ExecutorResourcePool.cpp.

Referenced by ExecutorResourceMgr_Namespace::ExecutorResourceMgr::request_resources_with_timeout().

                                            {
   ResourceGrant min_resource_grant, max_resource_grant;
 
   CHECK_LE(request_info.min_cpu_slots, request_info.cpu_slots);
   CHECK_LE(request_info.min_gpu_slots, request_info.gpu_slots);
   CHECK_LE(request_info.min_cpu_result_mem, request_info.cpu_result_mem);
 
   max_resource_grant.cpu_slots = calc_max_resource_grant_for_request(
       request_info.cpu_slots,
       request_info.min_cpu_slots,
       get_max_resource_grant_per_request(ResourceSubtype::CPU_SLOTS));
   if (max_resource_grant.cpu_slots == 0 && request_info.min_cpu_slots > 0) {
     throw QueryNeedsTooManyCpuSlots(
         get_max_resource_grant_per_request(ResourceSubtype::CPU_SLOTS),
         request_info.min_cpu_slots);
   }
 
   max_resource_grant.gpu_slots = calc_max_resource_grant_for_request(
       request_info.gpu_slots,
       request_info.min_gpu_slots,
       get_max_resource_grant_per_request(ResourceSubtype::GPU_SLOTS));
   if (max_resource_grant.gpu_slots == 0 && request_info.min_gpu_slots > 0) {
     throw QueryNeedsTooManyGpuSlots(
         get_max_resource_grant_per_request(ResourceSubtype::GPU_SLOTS),
         request_info.min_gpu_slots);
   }
 
   // Todo (todd): Modulate number of CPU threads launched to ensure that
   // query can fit in max grantable CPU result memory (if possible)
   max_resource_grant.cpu_result_mem = calc_max_resource_grant_for_request(
       request_info.cpu_result_mem,
       request_info.min_cpu_result_mem,
       get_max_resource_grant_per_request(ResourceSubtype::CPU_RESULT_MEM));
   if (max_resource_grant.cpu_result_mem == 0 && request_info.min_cpu_result_mem > 0) {
     throw QueryNeedsTooMuchCpuResultMem(
         get_max_resource_grant_per_request(ResourceSubtype::CPU_RESULT_MEM),
         request_info.min_cpu_result_mem);
   }
 
   const auto& chunk_request_info = request_info.chunk_request_info;
 
   const size_t max_pinned_buffer_pool_grant_for_memory_level =
       get_max_resource_grant_per_request(
           chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
               ? ResourceSubtype::PINNED_CPU_BUFFER_POOL_MEM
               : ResourceSubtype::PINNED_GPU_BUFFER_POOL_MEM);
 
   if (chunk_request_info.total_bytes > max_pinned_buffer_pool_grant_for_memory_level) {
     if (!chunk_request_info.bytes_scales_per_kernel) {
       throw QueryNeedsTooMuchBufferPoolMem(max_pinned_buffer_pool_grant_for_memory_level,
                                            chunk_request_info.total_bytes,
                                            chunk_request_info.device_memory_pool_type);
     }
     // If here we have bytes_needed_scales_per_kernel
     // For now, this can only be for a CPU request, but that may be relaxed down the
     // road
     const size_t max_pageable_buffer_pool_grant_for_memory_level =
         get_max_resource_grant_per_request(
             chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
                 ? ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM
                 : ResourceSubtype::PAGEABLE_GPU_BUFFER_POOL_MEM);
     CHECK(chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU);
     const auto max_chunk_memory_and_cpu_slots_grant =
         calc_max_dependent_resource_grant_for_request(
             chunk_request_info.total_bytes,  // requested_dependent_resource_quantity
             chunk_request_info
                 .max_bytes_per_kernel,  // min_requested_dependent_resource_quantity
             max_pageable_buffer_pool_grant_for_memory_level,  // max_grantable_dependent_resource_quantity
             request_info.min_cpu_slots,    // min_requested_independent_resource_quantity
             max_resource_grant.cpu_slots,  // max_grantable_indepndent_resource_quantity
             chunk_request_info
                 .max_bytes_per_kernel);  // dependent_to_independent_resource_ratio
 
     CHECK_LE(max_chunk_memory_and_cpu_slots_grant.second, max_resource_grant.cpu_slots);
     if (max_chunk_memory_and_cpu_slots_grant.first == size_t(0)) {
       // Make sure cpu_slots is 0 as well
       CHECK_EQ(max_chunk_memory_and_cpu_slots_grant.second, size_t(0));
       // Get what min grant would have been if it was grantable so that we can present a
       // meaningful error message
       const auto adjusted_min_chunk_memory_and_cpu_slots_grant =
           calc_min_dependent_resource_grant_for_request(
               chunk_request_info
                   .max_bytes_per_kernel,   // min_requested_dependent_resource_quantity
               request_info.min_cpu_slots,  // min_requested_independent_resource_quantity
               chunk_request_info
                   .max_bytes_per_kernel);  // dependent_to_independent_resource_ratio
       // Ensure we would not have been able to satisfy this grant
       CHECK_GT(adjusted_min_chunk_memory_and_cpu_slots_grant.first,
                max_pageable_buffer_pool_grant_for_memory_level);
       // The logic for calc_min_dependent_resource_grant_for_request is constrained to
       // at least return at least the min dependent resource quantity requested, here
       // CPU slots
       CHECK_GE(adjusted_min_chunk_memory_and_cpu_slots_grant.second,
                request_info.min_cpu_slots);
 
       // May need additional error message as we could fail even though bytes per kernel
       // < total buffer pool bytes, if cpu slots < min requested cpu slots
       throw QueryNeedsTooMuchBufferPoolMem(
           max_pageable_buffer_pool_grant_for_memory_level,
           adjusted_min_chunk_memory_and_cpu_slots_grant
               .first,  // min chunk memory grant (without chunk grant constraints)
           chunk_request_info.device_memory_pool_type);
     }
     // If here query is allowed but cpu slots are gated to gate number of chunks
     // simultaneously pinned We should have been gated to a minimum of our request's
     // min_cpu_slots
     CHECK_GE(max_chunk_memory_and_cpu_slots_grant.second, request_info.min_cpu_slots);
     max_resource_grant.cpu_slots = max_chunk_memory_and_cpu_slots_grant.second;
     max_resource_grant.buffer_mem_gated_per_slot = true;
     min_resource_grant.buffer_mem_gated_per_slot = true;
     max_resource_grant.buffer_mem_per_slot = chunk_request_info.max_bytes_per_kernel;
     min_resource_grant.buffer_mem_per_slot = chunk_request_info.max_bytes_per_kernel;
     max_resource_grant.buffer_mem_for_given_slots =
         chunk_request_info.max_bytes_per_kernel * max_resource_grant.cpu_slots;
     min_resource_grant.buffer_mem_for_given_slots =
         chunk_request_info.max_bytes_per_kernel * request_info.min_cpu_slots;
   }
 
   min_resource_grant.cpu_slots = request_info.min_cpu_slots;
   min_resource_grant.gpu_slots = request_info.min_gpu_slots;
   min_resource_grant.cpu_result_mem = request_info.cpu_result_mem;
 
   return std::make_pair(min_resource_grant, max_resource_grant);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< ResourceRequestGrant > ExecutorResourceMgr_Namespace::ExecutorResourcePool::calc_static_resource_grant_ranges_for_request ( const std::vector< ResourceRequest > & resource_requests ) const

Definition at line 337 of file ExecutorResourcePool.cpp.

References calc_max_resource_grant_for_request(), CHECK, CHECK_EQ, CHECK_LE, get_max_resource_grant_per_request(), ExecutorResourceMgr_Namespace::INVALID_SUBTYPE, ExecutorResourceMgr_Namespace::ResourceRequest::max_quantity, ExecutorResourceMgr_Namespace::ResourceRequest::resource_subtype, and throw_insufficient_resource_error().

                                                                {
   std::vector<ResourceRequestGrant> resource_request_grants;
 
   std::array<ResourceRequestGrant, ResourceSubtypeSize> all_resource_grants;
   for (const auto& resource_request : resource_requests) {
     CHECK(resource_request.resource_subtype != ResourceSubtype::INVALID_SUBTYPE);
     CHECK_LE(resource_request.min_quantity, resource_request.max_quantity);
 
     ResourceRequestGrant resource_grant;
     resource_grant.resource_subtype = resource_request.resource_subtype;
     resource_grant.max_quantity = calc_max_resource_grant_for_request(
         resource_request.max_quantity,
         resource_request.min_quantity,
         get_max_resource_grant_per_request(resource_request.resource_subtype));
     if (resource_grant.max_quantity < resource_request.min_quantity) {
       // Current implementation should always return 0 if it cannot grant requested amount
       CHECK_EQ(resource_grant.max_quantity, size_t(0));
       throw_insufficient_resource_error(resource_request.resource_subtype,
                                         resource_request.min_quantity);
     }
     all_resource_grants[static_cast<size_t>(resource_grant.resource_subtype)] =
         resource_grant;
   }
   return resource_request_grants;
 }

Here is the call graph for this function:

bool ExecutorResourceMgr_Namespace::ExecutorResourcePool::can_currently_satisfy_chunk_request	(	const ResourceGrant &	min_resource_grant,
		const ChunkRequestInfo &	chunk_request_info
	)		const

private

Definition at line 676 of file ExecutorResourcePool.cpp.

Referenced by can_currently_satisfy_request_impl().

                                                       {
   // Expects lock on resource_mutex_ already taken
 
   const size_t total_buffer_mem_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? get_total_resource(ResourceType::CPU_BUFFER_POOL_MEM)
           : get_total_resource(ResourceType::GPU_BUFFER_POOL_MEM);
   const size_t allocated_buffer_mem_for_memory_level =
       get_total_allocated_buffer_pool_mem_for_level(
           chunk_request_info.device_memory_pool_type);
 
   if (min_resource_grant.buffer_mem_gated_per_slot) {
     CHECK_GT(min_resource_grant.buffer_mem_per_slot, size_t(0));
     // We only allow scaling back slots to cap buffer pool memory required on CPU
     // currently
     CHECK(chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU);
     const size_t min_buffer_pool_mem_required =
         min_resource_grant.cpu_slots * min_resource_grant.buffer_mem_per_slot;
     // Below is a sanity check... we'll never be able to run the query if minimum pool
     // memory required is not <= the total buffer pool memory
     CHECK_LE(min_buffer_pool_mem_required, total_buffer_mem_for_memory_level);
     return allocated_buffer_mem_for_memory_level + min_buffer_pool_mem_required <=
            total_buffer_mem_for_memory_level;
   }
 
   // CHECK and not exception as parent should have checked this, can re-evaluate whether
   // should be exception
   CHECK_LE(chunk_request_info.total_bytes, total_buffer_mem_for_memory_level);
   const size_t chunk_bytes_not_in_pool = get_chunk_bytes_not_in_pool(chunk_request_info);
   if (ENABLE_DEBUG_PRINTING) {
     debug_print("Chunk bytes not in pool: ", format_num_bytes(chunk_bytes_not_in_pool));
   }
   return chunk_bytes_not_in_pool + allocated_buffer_mem_for_memory_level <=
          total_buffer_mem_for_memory_level;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ExecutorResourceMgr_Namespace::ExecutorResourcePool::can_currently_satisfy_request	(	const ResourceGrant &	min_resource_grant,
		const ChunkRequestInfo &	chunk_request_info
	)		const

Definition at line 910 of file ExecutorResourcePool.cpp.

References can_currently_satisfy_request_impl(), and resource_mutex_.

                                                       {
   std::shared_lock<std::shared_mutex> resource_read_lock(resource_mutex_);
   return can_currently_satisfy_request_impl(min_resource_grant, chunk_request_info);
 }

Here is the call graph for this function:

bool ExecutorResourceMgr_Namespace::ExecutorResourcePool::can_currently_satisfy_request_impl	(	const ResourceGrant &	min_resource_grant,
		const ChunkRequestInfo &	chunk_request_info
	)		const

private

Definition at line 555 of file ExecutorResourcePool.cpp.

References can_currently_satisfy_chunk_request(), check_request_against_global_policy(), check_request_against_policy(), ExecutorResourceMgr_Namespace::CPU_RESULT_MEM, ExecutorResourceMgr_Namespace::ResourceGrant::cpu_result_mem, ExecutorResourceMgr_Namespace::CPU_SLOTS, ExecutorResourceMgr_Namespace::ResourceGrant::cpu_slots, get_allocated_resource_of_type(), get_concurrent_resource_grant_policy(), get_max_resource_grant_per_request(), get_total_resource(), ExecutorResourceMgr_Namespace::GPU_SLOTS, ExecutorResourceMgr_Namespace::ResourceGrant::gpu_slots, and outstanding_num_requests_.

Referenced by allocate_resources(), can_currently_satisfy_request(), and determine_dynamic_resource_grant().

                                                       {
   // Currently expects to be protected by mutex from ExecutorResourceMgr
 
   // Arguably exceptions below shouldn't happen as resource_grant,
   // if generated by ExecutorResourcePool per design, should be within
   // per query max limits. But since this is an external class api call and
   // the input could be anything provided by the caller, and we may want
   // to allow for dynamic per query limits, throwing instead of CHECKing
   // for now, but may re-evaluate.
 
   if (min_resource_grant.cpu_slots >
       get_max_resource_grant_per_request(ResourceSubtype::CPU_SLOTS)) {
     throw QueryNeedsTooManyCpuSlots(
         get_max_resource_grant_per_request(ResourceSubtype::CPU_SLOTS),
         min_resource_grant.cpu_slots);
   }
   if (min_resource_grant.gpu_slots >
       get_max_resource_grant_per_request(ResourceSubtype::GPU_SLOTS)) {
     throw QueryNeedsTooManyGpuSlots(
         get_max_resource_grant_per_request(ResourceSubtype::GPU_SLOTS),
         min_resource_grant.gpu_slots);
   }
   if (min_resource_grant.cpu_result_mem >
       get_max_resource_grant_per_request(ResourceSubtype::CPU_RESULT_MEM)) {
     throw QueryNeedsTooMuchCpuResultMem(
         get_max_resource_grant_per_request(ResourceSubtype::CPU_RESULT_MEM),
         min_resource_grant.cpu_result_mem);
   }
 
   // First check if request is in violation of any global
   // ALLOW_SINGLE_GLOBAL_REQUEST policies
 
   if (!check_request_against_global_policy(
           get_total_resource(ResourceType::CPU_SLOTS),
           get_allocated_resource_of_type(ResourceType::CPU_SLOTS),
           get_concurrent_resource_grant_policy(ResourceType::CPU_SLOTS))) {
     return false;
   }
   if (!check_request_against_global_policy(
           get_total_resource(ResourceType::GPU_SLOTS),
           get_allocated_resource_of_type(ResourceType::GPU_SLOTS),
           get_concurrent_resource_grant_policy(ResourceType::GPU_SLOTS))) {
     return false;
   }
   if (!check_request_against_global_policy(
           get_total_resource(ResourceType::CPU_RESULT_MEM),
           get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM),
           get_concurrent_resource_grant_policy(ResourceType::CPU_RESULT_MEM))) {
     return false;
   }
 
   const bool can_satisfy_cpu_slots_request = check_request_against_policy(
       min_resource_grant.cpu_slots,
       get_total_resource(ResourceType::CPU_SLOTS),
       get_allocated_resource_of_type(ResourceType::CPU_SLOTS),
       outstanding_num_requests_,
       get_concurrent_resource_grant_policy(ResourceType::CPU_SLOTS));
 
   const bool can_satisfy_gpu_slots_request = check_request_against_policy(
       min_resource_grant.gpu_slots,
       get_total_resource(ResourceType::GPU_SLOTS),
       get_allocated_resource_of_type(ResourceType::GPU_SLOTS),
       outstanding_num_requests_,
       get_concurrent_resource_grant_policy(ResourceType::GPU_SLOTS));
 
   const bool can_satisfy_cpu_result_mem_request = check_request_against_policy(
       min_resource_grant.cpu_result_mem,
       get_total_resource(ResourceType::CPU_RESULT_MEM),
       get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM),
       outstanding_num_requests_,
       get_concurrent_resource_grant_policy(ResourceType::CPU_RESULT_MEM));
 
   // Short circuit before heavier chunk check operation
   if (!(can_satisfy_cpu_slots_request && can_satisfy_gpu_slots_request &&
         can_satisfy_cpu_result_mem_request)) {
     return false;
   }
 
   return can_currently_satisfy_chunk_request(min_resource_grant, chunk_request_info);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ExecutorResourceMgr_Namespace::ExecutorResourcePool::check_request_against_global_policy	(	const size_t	resource_total,
		const size_t	resource_allocated,
		const ConcurrentResourceGrantPolicy &	concurrent_resource_grant_policy
	)		const

private

Definition at line 491 of file ExecutorResourcePool.cpp.

References ExecutorResourceMgr_Namespace::ALLOW_SINGLE_REQUEST_GLOBALLY, ExecutorResourceMgr_Namespace::ConcurrentResourceGrantPolicy::concurrency_policy, and ExecutorResourceMgr_Namespace::ConcurrentResourceGrantPolicy::oversubscription_concurrency_policy.

Referenced by can_currently_satisfy_request_impl().

                                                                                  {
   if (concurrent_resource_grant_policy.concurrency_policy ==
           ResourceConcurrencyPolicy::ALLOW_SINGLE_REQUEST_GLOBALLY &&
       resource_allocated > 0) {
     return false;
   }
   if (concurrent_resource_grant_policy.oversubscription_concurrency_policy ==
           ResourceConcurrencyPolicy::ALLOW_SINGLE_REQUEST_GLOBALLY &&
       resource_allocated > resource_total) {
     return false;
   }
   return true;
 }

Here is the caller graph for this function:

bool ExecutorResourceMgr_Namespace::ExecutorResourcePool::check_request_against_policy	(	const size_t	resource_request,
		const size_t	resource_total,
		const size_t	resource_allocated,
		const size_t	global_outstanding_requests,
		const ConcurrentResourceGrantPolicy &	concurrent_resource_grant_policy
	)		const

private

Definition at line 508 of file ExecutorResourcePool.cpp.

References ExecutorResourceMgr_Namespace::ALLOW_CONCURRENT_REQUESTS, ExecutorResourceMgr_Namespace::ALLOW_SINGLE_REQUEST, ExecutorResourceMgr_Namespace::ALLOW_SINGLE_REQUEST_GLOBALLY, ExecutorResourceMgr_Namespace::ConcurrentResourceGrantPolicy::concurrency_policy, ExecutorResourceMgr_Namespace::DISALLOW_REQUESTS, ExecutorResourceMgr_Namespace::ConcurrentResourceGrantPolicy::oversubscription_concurrency_policy, and UNREACHABLE.

Referenced by can_currently_satisfy_request_impl().

                                                                                  {
   auto test_request_against_policy =
       [min_resource_request, resource_allocated, global_outstanding_requests](
           const ResourceConcurrencyPolicy& resource_concurrency_policy) {
         switch (resource_concurrency_policy) {
           case ResourceConcurrencyPolicy::DISALLOW_REQUESTS: {
             // DISALLOW_REQUESTS for undersubscription policy doesn't make much sense as
             // a resource pool-wide policy (unless we are using it as a sanity check for
             // something like CPU mode), but planning to implement per-query or priority
             // level policies so will leave for now
             return min_resource_request == 0;
           }
           case ResourceConcurrencyPolicy::ALLOW_SINGLE_REQUEST_GLOBALLY: {
             // redundant with check_request_against_global_policy,
             // so considered CHECKing instead that the following cannot
             // be true, but didn't want to couple the two functions
             return global_outstanding_requests == 0;
           }
           case ResourceConcurrencyPolicy::ALLOW_SINGLE_REQUEST: {
             return min_resource_request == 0 || resource_allocated == 0;
           }
           case ResourceConcurrencyPolicy::ALLOW_CONCURRENT_REQUESTS: {
             return true;
           }
           default:
             UNREACHABLE();
         }
         return false;
       };
 
   if (!test_request_against_policy(concurrent_resource_grant_policy.concurrency_policy)) {
     return false;
   }
   if (min_resource_request + resource_allocated <= resource_total) {
     return true;
   }
   return test_request_against_policy(
       concurrent_resource_grant_policy.oversubscription_concurrency_policy);
 }

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::deallocate_resources	(	const ResourceGrant &	resource_grant,
		const ChunkRequestInfo &	chunk_request_info
	)

Deallocates resources granted to a requestor such that they can be used for other requests.

Parameters

resource_grant	- Resources granted to the request that should be deallocated
chunk_request_info	- The DataMgr chunk keys (and other associated info) granted to this query that should be deallocated.

Definition at line 1087 of file ExecutorResourcePool.cpp.

Referenced by ExecutorResourceMgr_Namespace::ExecutorResourceMgr::release_resources().

                                                 {
   std::unique_lock<std::shared_mutex> resource_write_lock(resource_mutex_);
 
   // Caller (ExecutorResourceMgr) should never request resource allocation for a request
   // it knows cannot be granted, however use below as a sanity check
 
   CHECK_LE(resource_grant.cpu_slots,
            get_allocated_resource_of_type(ResourceType::CPU_SLOTS));
   CHECK_LE(resource_grant.gpu_slots,
            get_allocated_resource_of_type(ResourceType::GPU_SLOTS));
   CHECK_LE(resource_grant.cpu_result_mem,
            get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM));
 
   allocated_resources_[static_cast<size_t>(ResourceSubtype::CPU_SLOTS)] -=
       resource_grant.cpu_slots;
   allocated_resources_[static_cast<size_t>(ResourceSubtype::GPU_SLOTS)] -=
       resource_grant.gpu_slots;
   allocated_resources_[static_cast<size_t>(ResourceSubtype::CPU_RESULT_MEM)] -=
       resource_grant.cpu_result_mem;
 
   outstanding_num_requests_--;
   if (resource_grant.cpu_slots > 0) {
     decrement_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS);
   }
   if (resource_grant.gpu_slots > 0) {
     decrement_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS);
   }
   if (resource_grant.cpu_result_mem > 0) {
     decrement_outstanding_per_resource_num_requests(ResourceType::CPU_RESULT_MEM);
   }
   if (chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU) {
     if (resource_grant.buffer_mem_gated_per_slot ||
         (chunk_request_info.num_chunks > 0 && chunk_request_info.total_bytes > 0)) {
       decrement_outstanding_per_resource_num_requests(ResourceType::CPU_BUFFER_POOL_MEM);
     }
   } else if (chunk_request_info.device_memory_pool_type == ExecutorDeviceType::GPU) {
     if (resource_grant.buffer_mem_gated_per_slot ||
         (chunk_request_info.num_chunks > 0 && chunk_request_info.total_bytes > 0)) {
       decrement_outstanding_per_resource_num_requests(ResourceType::GPU_BUFFER_POOL_MEM);
     }
   }
 
   LOG(EXECUTOR) << "ExecutorResourcePool de-allocation: " << outstanding_num_requests_
                 << " requests ("
                 << get_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS)
                 << " CPU | "
                 << get_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS)
                 << " GPU)";
   LOG(EXECUTOR) << "ExecutorResourcePool state: CPU slots: "
                 << get_allocated_resource_of_type(ResourceType::CPU_SLOTS) << " of "
                 << get_total_resource(ResourceType::CPU_SLOTS) << " | GPU slots: "
                 << get_allocated_resource_of_type(ResourceType::GPU_SLOTS) << " of "
                 << get_total_resource(ResourceType::GPU_SLOTS) << " CPU result mem: "
                 << format_num_bytes(
                        get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM))
                 << " of "
                 << format_num_bytes(get_total_resource(ResourceType::CPU_RESULT_MEM));
   remove_chunk_requests_from_allocated_pool(resource_grant, chunk_request_info);
 
   if (sanity_check_pool_state_on_deallocations_) {
     sanity_check_requests_against_allocations();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::decrement_outstanding_per_resource_num_requests ( const ResourceType resource_type )

inlineprivate

Definition at line 519 of file ExecutorResourcePool.h.

References outstanding_per_resource_num_requests_.

Referenced by deallocate_resources().

                                         {
     return --outstanding_per_resource_num_requests_[static_cast<size_t>(resource_type)];
   }

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::decrement_total_per_resource_num_requests ( const ResourceType resource_type )

inlineprivate

Definition at line 504 of file ExecutorResourcePool.h.

References total_per_resource_num_requests_.

                                         {
     return --total_per_resource_num_requests_[static_cast<size_t>(resource_type)];
   }

std::pair< bool, ResourceGrant > ExecutorResourceMgr_Namespace::ExecutorResourcePool::determine_dynamic_resource_grant	(	const ResourceGrant &	min_resource_grant,
		const ResourceGrant &	max_resource_grant,
		const ChunkRequestInfo &	chunk_request_info,
		const double	max_request_backoff_ratio
	)		const

Determines the actual resource grant to give a query (which will be somewhere between the provided min_resource_grant and max_resource_grant, unless it is determined that the request cannot be currently satisfied).

Generally the resources granted of each type are computed independently, but if buffer_mem_gated_per_slot is set on min_resource_grant, other resources such as threads granted may be scaled back to match the amount of buffer pool mem available.

Parameters

min_resource_grant	- The min resource grant allowable for this request, determined in calc_min_max_resource_grants_for_request
max_resource_grant	- The max resource grant possible for this request, determined in calc_min_max_resource_grants_for_request
chunk_request_info	- The DataMgr chunks with associated sizes needed for this query
max_request_backoff_ratio	- The fraction from 0 to 1 of each resource we will leave in the pool, even if the resources are available to satisfy the max_resource_grant (so that there will be resources available for other queries).

Returns: std::pair<bool, ResourceGrant> - the first boolean member of the pair specifies whether the request can currently be satisfied given current resources in the pool, the second is the actual resource grant a requestor will receive.

Definition at line 936 of file ExecutorResourcePool.cpp.

Referenced by ExecutorResourceMgr_Namespace::ExecutorResourceMgr::choose_next_request().

                                                   {
   std::unique_lock<std::shared_mutex> resource_write_lock(resource_mutex_);
   CHECK_LE(max_request_backoff_ratio, 1.0);
   const bool can_satisfy_request =
       can_currently_satisfy_request_impl(min_resource_grant, chunk_request_info);
   ResourceGrant actual_resource_grant;
   if (!can_satisfy_request) {
     return std::make_pair(false, actual_resource_grant);
   }
   actual_resource_grant.cpu_slots = determine_dynamic_single_resource_grant(
       min_resource_grant.cpu_slots,
       max_resource_grant.cpu_slots,
       get_allocated_resource_of_type(ResourceType::CPU_SLOTS),
       get_total_resource(ResourceType::CPU_SLOTS),
       max_request_backoff_ratio);
   actual_resource_grant.gpu_slots = determine_dynamic_single_resource_grant(
       min_resource_grant.gpu_slots,
       max_resource_grant.gpu_slots,
       get_allocated_resource_of_type(ResourceType::GPU_SLOTS),
       get_total_resource(ResourceType::GPU_SLOTS),
       max_request_backoff_ratio);
   // Todo (todd): Modulate number of CPU threads launched to ensure that
   // query can fit in currently available CPU result memory
   actual_resource_grant.cpu_result_mem = determine_dynamic_single_resource_grant(
       min_resource_grant.cpu_result_mem,
       max_resource_grant.cpu_result_mem,
       get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM),
       get_total_resource(ResourceType::CPU_RESULT_MEM),
       max_request_backoff_ratio);
   if (min_resource_grant.buffer_mem_gated_per_slot) {
     CHECK(chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU);
     // Below is quite redundant, but can revisit
     CHECK_EQ(chunk_request_info.max_bytes_per_kernel,
              min_resource_grant.buffer_mem_per_slot);
     CHECK_EQ(chunk_request_info.max_bytes_per_kernel,
              max_resource_grant.buffer_mem_per_slot);
 
     const size_t allocated_buffer_mem_for_memory_level =
         chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
             ? get_allocated_resource_of_type(ResourceType::CPU_BUFFER_POOL_MEM)
             : get_allocated_resource_of_type(ResourceType::GPU_BUFFER_POOL_MEM);
     const size_t total_buffer_mem_for_memory_level =
         chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
             ? get_total_resource(ResourceType::CPU_BUFFER_POOL_MEM)
             : get_total_resource(ResourceType::GPU_BUFFER_POOL_MEM);
 
     CHECK_LE(allocated_buffer_mem_for_memory_level, total_buffer_mem_for_memory_level);
 
     const size_t remaining_buffer_mem_for_memory_level =
         total_buffer_mem_for_memory_level - allocated_buffer_mem_for_memory_level;
 
     CHECK_LE(min_resource_grant.buffer_mem_for_given_slots,
              remaining_buffer_mem_for_memory_level);
     const size_t max_grantable_mem =
         std::min(remaining_buffer_mem_for_memory_level,
                  max_resource_grant.buffer_mem_for_given_slots);
     const auto granted_buffer_mem_and_cpu_slots =
         calc_max_dependent_resource_grant_for_request(
             chunk_request_info.total_bytes,  // requested_dependent_resource_quantity
             min_resource_grant
                 .buffer_mem_for_given_slots,  // min_requested_dependent_resource_quantity
             max_grantable_mem,                // max_grantable_dependent_resource_quantity
             min_resource_grant.cpu_slots,  // min_requested_independent_resource_quantity
             max_resource_grant.cpu_slots,  // max_grantable_independent_resource_quantity
             chunk_request_info
                 .max_bytes_per_kernel);  // dependent_to_independent_resource_ratio
     const size_t granted_buffer_mem = granted_buffer_mem_and_cpu_slots.first;
     const size_t granted_cpu_slots = granted_buffer_mem_and_cpu_slots.second;
     CHECK_EQ(granted_buffer_mem,
              granted_cpu_slots * chunk_request_info.max_bytes_per_kernel);
     CHECK_GE(granted_cpu_slots, min_resource_grant.cpu_slots);
     CHECK_LE(granted_cpu_slots, max_resource_grant.cpu_slots);
     actual_resource_grant.buffer_mem_gated_per_slot = true;
     actual_resource_grant.buffer_mem_per_slot = chunk_request_info.max_bytes_per_kernel;
     actual_resource_grant.buffer_mem_for_given_slots = granted_buffer_mem;
     actual_resource_grant.cpu_slots =
         granted_cpu_slots;  // Override cpu slots with restricted dependent resource
                             // calc
   }
   return std::make_pair(true, actual_resource_grant);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::determine_dynamic_single_resource_grant	(	const size_t	min_resource_requested,
		const size_t	max_resource_requested,
		const size_t	resource_allocated,
		const size_t	total_resource,
		const double	max_request_backoff_ratio
	)		const

private

Definition at line 917 of file ExecutorResourcePool.cpp.

References CHECK_LE.

Referenced by determine_dynamic_resource_grant().

                                                   {
   CHECK_LE(min_resource_requested, max_resource_requested);
   if (min_resource_requested + resource_allocated >= total_resource) {
     return min_resource_requested;
   }
   // The below is safe in unsigned math as we know that resource_allocated <
   // total_resource from the above conditional
   const size_t resource_remaining = total_resource - resource_allocated;
   return std::max(min_resource_requested,
                   std::min(max_resource_requested,
                            static_cast<size_t>(
                                round(max_request_backoff_ratio * resource_remaining))));
 }

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_allocated_resource_of_subtype ( const ResourceSubtype resource_subtype ) const

inlineprivate

Definition at line 482 of file ExecutorResourcePool.h.

References allocated_resources_.

Referenced by add_chunk_requests_to_allocated_pool(), get_allocated_resource_of_type(), get_resource_info(), and remove_chunk_requests_from_allocated_pool().

                                                     {
     return allocated_resources_[static_cast<size_t>(resource_subtype)];
   }

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_allocated_resource_of_type ( const ResourceType resource_type ) const

private

Definition at line 169 of file ExecutorResourcePool.cpp.

References get_allocated_resource_of_subtype(), and ExecutorResourceMgr_Namespace::map_resource_type_to_resource_subtypes().

Referenced by allocate_resources(), can_currently_satisfy_request_impl(), deallocate_resources(), determine_dynamic_resource_grant(), get_resource_info(), get_total_allocated_buffer_pool_mem_for_level(), remove_chunk_requests_from_allocated_pool(), and sanity_check_requests_against_allocations().

                                             {
   const auto resource_subtypes = map_resource_type_to_resource_subtypes(resource_type);
   size_t resource_type_allocation_sum{0};
   for (const auto& resource_subtype : resource_subtypes) {
     resource_type_allocation_sum += get_allocated_resource_of_subtype(resource_subtype);
   }
   return resource_type_allocation_sum;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_chunk_bytes_not_in_pool ( const ChunkRequestInfo & chunk_request_info ) const

private

Definition at line 658 of file ExecutorResourcePool.cpp.

References allocated_cpu_buffer_pool_chunks_, allocated_gpu_buffer_pool_chunks_, ExecutorResourceMgr_Namespace::ChunkRequestInfo::chunks_with_byte_sizes, CPU, and ExecutorResourceMgr_Namespace::ChunkRequestInfo::device_memory_pool_type.

Referenced by can_currently_satisfy_chunk_request().

                                                       {
   const BufferPoolChunkMap& chunk_map_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? allocated_cpu_buffer_pool_chunks_
           : allocated_gpu_buffer_pool_chunks_;
   size_t chunk_bytes_not_in_pool{0};
   for (const auto& requested_chunk : chunk_request_info.chunks_with_byte_sizes) {
     const auto chunk_itr = chunk_map_for_memory_level.find(requested_chunk.first);
     if (chunk_itr == chunk_map_for_memory_level.end()) {
       chunk_bytes_not_in_pool += requested_chunk.second;
     } else if (requested_chunk.second > chunk_itr->second.second) {
       chunk_bytes_not_in_pool += requested_chunk.second - chunk_itr->second.second;
     }
   }
   return chunk_bytes_not_in_pool;
 }

Here is the caller graph for this function:

ConcurrentResourceGrantPolicy ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_concurrent_resource_grant_policy ( const ResourceType resource_type ) const

inline

Definition at line 369 of file ExecutorResourcePool.h.

References concurrent_resource_grant_policies_.

Referenced by can_currently_satisfy_request_impl(), ExecutorResourceMgr_Namespace::ExecutorResourceMgr::get_concurrent_resource_grant_policy(), init_max_resource_grants_per_requests(), log_parameters(), and ExecutorResourceMgr_Namespace::ExecutorResourceMgr::set_concurrent_resource_grant_policy().

                                               {
     return concurrent_resource_grant_policies_[static_cast<size_t>(resource_type)];
   }

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_max_resource_grant_per_request ( const ResourceSubtype resource_subtype ) const

inlineprivate

Definition at line 489 of file ExecutorResourcePool.h.

References max_resource_grants_per_request_.

Referenced by calc_min_max_resource_grants_for_request(), calc_static_resource_grant_ranges_for_request(), can_currently_satisfy_request_impl(), and throw_insufficient_resource_error().

                                                     {
     return max_resource_grants_per_request_[static_cast<size_t>(resource_subtype)];
   }

Here is the caller graph for this function:

const ResourceGrantPolicy& ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_max_resource_grant_per_request_policy ( const ResourceSubtype resource_subtype ) const

inline

Definition at line 374 of file ExecutorResourcePool.h.

References max_resource_grants_per_request_policies_.

Referenced by log_parameters().

                                                     {
     return max_resource_grants_per_request_policies_[static_cast<size_t>(
         resource_subtype)];
   }

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_outstanding_per_resource_num_requests ( const ResourceType resource_type ) const

inlineprivate

Definition at line 509 of file ExecutorResourcePool.h.

References outstanding_per_resource_num_requests_.

Referenced by allocate_resources(), deallocate_resources(), get_resource_info(), and sanity_check_requests_against_allocations().

                                               {
     return outstanding_per_resource_num_requests_[static_cast<size_t>(resource_type)];
   }

Here is the caller graph for this function:

ChunkRequestInfo ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_requested_chunks_not_in_pool ( const ChunkRequestInfo & chunk_request_info ) const

private

Definition at line 638 of file ExecutorResourcePool.cpp.

References allocated_cpu_buffer_pool_chunks_, allocated_gpu_buffer_pool_chunks_, ExecutorResourceMgr_Namespace::ChunkRequestInfo::chunks_with_byte_sizes, CPU, ExecutorResourceMgr_Namespace::ChunkRequestInfo::device_memory_pool_type, ExecutorResourceMgr_Namespace::ChunkRequestInfo::num_chunks, and ExecutorResourceMgr_Namespace::ChunkRequestInfo::total_bytes.

                                                       {
   const BufferPoolChunkMap& chunk_map_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? allocated_cpu_buffer_pool_chunks_
           : allocated_gpu_buffer_pool_chunks_;
   ChunkRequestInfo missing_chunk_info;
   missing_chunk_info.device_memory_pool_type = chunk_request_info.device_memory_pool_type;
   std::vector<std::pair<ChunkKey, size_t>> missing_chunks_with_byte_sizes;
   for (const auto& requested_chunk : chunk_request_info.chunks_with_byte_sizes) {
     if (chunk_map_for_memory_level.find(requested_chunk.first) ==
         chunk_map_for_memory_level.end()) {
       missing_chunk_info.chunks_with_byte_sizes.emplace_back(requested_chunk);
       missing_chunk_info.total_bytes += requested_chunk.second;
     }
   }
   missing_chunk_info.num_chunks = missing_chunk_info.chunks_with_byte_sizes.size();
   return missing_chunk_info;
 }

std::pair< size_t, size_t > ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_resource_info ( const ResourceType resource_type ) const

Returns the allocated and total available amount of the resource specified.

Returns: std::pair<size_t, size_t> - First member is the allocated amount of the resource, the second member is the total amount of the resource (including allocated and available)

Definition at line 179 of file ExecutorResourcePool.cpp.

References get_allocated_resource_of_type(), get_total_resource(), and resource_mutex_.

Referenced by ExecutorResourceMgr_Namespace::ExecutorResourceMgr::get_resource_info().

                                             {
   std::shared_lock<std::shared_mutex> resource_read_lock(resource_mutex_);
   return std::make_pair(get_allocated_resource_of_type(resource_type),
                         get_total_resource(resource_type));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ResourcePoolInfo ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_resource_info ( ) const

Returns a struct detailing the allocated and total available resources of each type tracked in ExecutorResourcePool.

Returns: ResourcePoolInfo - Struct detailining the allocaated and total available resources of each typed tracked in ExecutorResourcePool

Definition at line 186 of file ExecutorResourcePool.cpp.

References allocated_cpu_buffer_pool_chunks_, allocated_gpu_buffer_pool_chunks_, ExecutorResourceMgr_Namespace::CPU_BUFFER_POOL_MEM, ExecutorResourceMgr_Namespace::CPU_RESULT_MEM, ExecutorResourceMgr_Namespace::CPU_SLOTS, get_allocated_resource_of_subtype(), get_allocated_resource_of_type(), get_outstanding_per_resource_num_requests(), get_total_resource(), ExecutorResourceMgr_Namespace::GPU_BUFFER_POOL_MEM, ExecutorResourceMgr_Namespace::GPU_SLOTS, outstanding_num_requests_, ExecutorResourceMgr_Namespace::PAGEABLE_CPU_BUFFER_POOL_MEM, ExecutorResourceMgr_Namespace::PAGEABLE_GPU_BUFFER_POOL_MEM, resource_mutex_, and total_num_requests_.

                                                                {
   std::shared_lock<std::shared_mutex> resource_read_lock(resource_mutex_);
   return ResourcePoolInfo(
       get_total_resource(ResourceType::CPU_SLOTS),
       get_total_resource(ResourceType::GPU_SLOTS),
       get_total_resource(ResourceType::CPU_RESULT_MEM),
       get_total_resource(ResourceType::CPU_BUFFER_POOL_MEM),
       get_total_resource(ResourceType::GPU_BUFFER_POOL_MEM),
       get_allocated_resource_of_type(ResourceType::CPU_SLOTS),
       get_allocated_resource_of_type(ResourceType::GPU_SLOTS),
       get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM),
       get_allocated_resource_of_type(ResourceType::CPU_BUFFER_POOL_MEM),
       get_allocated_resource_of_type(ResourceType::GPU_BUFFER_POOL_MEM),
       allocated_cpu_buffer_pool_chunks_.size(),
       allocated_gpu_buffer_pool_chunks_.size(),
       get_allocated_resource_of_subtype(ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM),
       get_allocated_resource_of_subtype(ResourceSubtype::PAGEABLE_GPU_BUFFER_POOL_MEM),
       total_num_requests_,
       outstanding_num_requests_,
       get_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS),
       get_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS),
       get_outstanding_per_resource_num_requests(ResourceType::CPU_RESULT_MEM),
       get_outstanding_per_resource_num_requests(ResourceType::CPU_BUFFER_POOL_MEM),
       get_outstanding_per_resource_num_requests(ResourceType::GPU_BUFFER_POOL_MEM));
 }

Here is the call graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_total_allocated_buffer_pool_mem_for_level ( const ExecutorDeviceType memory_pool_type ) const

inlineprivate

Definition at line 467 of file ExecutorResourcePool.h.

References CPU, ExecutorResourceMgr_Namespace::CPU_BUFFER_POOL_MEM, get_allocated_resource_of_type(), and ExecutorResourceMgr_Namespace::GPU_BUFFER_POOL_MEM.

Referenced by add_chunk_requests_to_allocated_pool(), and can_currently_satisfy_chunk_request().

                                                        {
     return memory_pool_type == ExecutorDeviceType::CPU
                ? get_allocated_resource_of_type(ResourceType::CPU_BUFFER_POOL_MEM)
                : get_allocated_resource_of_type(ResourceType::GPU_BUFFER_POOL_MEM);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_total_per_resource_num_requests ( const ResourceType resource_type ) const

inlineprivate

Definition at line 494 of file ExecutorResourcePool.h.

References total_per_resource_num_requests_.

                                               {
     return total_per_resource_num_requests_[static_cast<size_t>(resource_type)];
   }

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::get_total_resource ( const ResourceType resource_type ) const

inlineprivate

Definition at line 478 of file ExecutorResourcePool.h.

References total_resources_.

Referenced by add_chunk_requests_to_allocated_pool(), allocate_resources(), can_currently_satisfy_chunk_request(), can_currently_satisfy_request_impl(), deallocate_resources(), determine_dynamic_resource_grant(), get_resource_info(), init_max_resource_grants_per_requests(), log_parameters(), and remove_chunk_requests_from_allocated_pool().

                                                                            {
     return total_resources_[static_cast<size_t>(resource_type)];
   }

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::increment_outstanding_per_resource_num_requests ( const ResourceType resource_type )

inlineprivate

Definition at line 514 of file ExecutorResourcePool.h.

References outstanding_per_resource_num_requests_.

Referenced by allocate_resources().

                                         {
     return ++outstanding_per_resource_num_requests_[static_cast<size_t>(resource_type)];
   }

Here is the caller graph for this function:

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::increment_total_per_resource_num_requests ( const ResourceType resource_type )

inlineprivate

Definition at line 499 of file ExecutorResourcePool.h.

References total_per_resource_num_requests_.

Referenced by allocate_resources().

                                         {
     return ++total_per_resource_num_requests_[static_cast<size_t>(resource_type)];
   }

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::init	(	const std::vector< std::pair< ResourceType, size_t >> &	total_resources,
		const std::vector< ConcurrentResourceGrantPolicy > &	concurrent_resource_grant_policies,
		const std::vector< ResourceGrantPolicy > &	max_per_request_resource_grant_policies
	)

private

Definition at line 58 of file ExecutorResourcePool.cpp.

References concurrent_resource_grant_policies_, init_concurrency_policies(), init_max_resource_grants_per_requests(), ExecutorResourceMgr_Namespace::INVALID_SUBTYPE, ExecutorResourceMgr_Namespace::INVALID_TYPE, max_resource_grants_per_request_policies_, resource_type_validity_, and total_resources_.

Referenced by ExecutorResourcePool(), set_concurrent_resource_grant_policy(), and set_resource().

                                                                                     {
   for (const auto& total_resource : total_resources) {
     if (total_resource.first == ResourceType::INVALID_TYPE) {
       continue;
     }
     total_resources_[static_cast<size_t>(total_resource.first)] = total_resource.second;
     resource_type_validity_[static_cast<size_t>(total_resource.first)] = true;
   }
 
   for (const auto& concurrent_resource_grant_policy :
        concurrent_resource_grant_policies) {
     const ResourceType resource_type = concurrent_resource_grant_policy.resource_type;
     if (resource_type == ResourceType::INVALID_TYPE) {
       continue;
     }
     concurrent_resource_grant_policies_[static_cast<size_t>(resource_type)] =
         concurrent_resource_grant_policy;
   }
 
   for (const auto& max_resource_grant_per_request_policy :
        max_resource_grants_per_request_policies) {
     const ResourceSubtype resource_subtype =
         max_resource_grant_per_request_policy.resource_subtype;
     if (resource_subtype == ResourceSubtype::INVALID_SUBTYPE) {
       continue;
     }
     max_resource_grants_per_request_policies_[static_cast<size_t>(resource_subtype)] =
         max_resource_grant_per_request_policy;
   }
 
   init_concurrency_policies();
   init_max_resource_grants_per_requests();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::init_concurrency_policies ( )

private

Definition at line 95 of file ExecutorResourcePool.cpp.

References ExecutorResourceMgr_Namespace::ALLOW_SINGLE_REQUEST, CHECK, concurrent_resource_grant_policies_, ExecutorResourceMgr_Namespace::DISALLOW_REQUESTS, ExecutorResourceMgr_Namespace::INVALID_TYPE, and is_resource_valid().

Referenced by init().

                                                      {
   size_t resource_type_idx = 0;
   for (auto& concurrent_resource_grant_policy : concurrent_resource_grant_policies_) {
     const auto resource_type = static_cast<ResourceType>(resource_type_idx);
     const auto concurrency_policy_resource_type =
         concurrent_resource_grant_policy.resource_type;
     CHECK(resource_type == concurrency_policy_resource_type ||
           concurrency_policy_resource_type == ResourceType::INVALID_TYPE);
     if (is_resource_valid(resource_type)) {
       if (concurrency_policy_resource_type == ResourceType::INVALID_TYPE) {
         concurrent_resource_grant_policy.resource_type = resource_type;
         concurrent_resource_grant_policy.concurrency_policy =
             ResourceConcurrencyPolicy::ALLOW_SINGLE_REQUEST;
         concurrent_resource_grant_policy.oversubscription_concurrency_policy =
             ResourceConcurrencyPolicy::DISALLOW_REQUESTS;
       }
     } else {
       concurrent_resource_grant_policy.resource_type = ResourceType::INVALID_TYPE;
     }
     resource_type_idx++;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::init_max_resource_grants_per_requests ( )

private

Definition at line 118 of file ExecutorResourcePool.cpp.

References CHECK, ExecutorResourceMgr_Namespace::DISALLOW_REQUESTS, get_concurrent_resource_grant_policy(), get_total_resource(), ExecutorResourceMgr_Namespace::INVALID_SUBTYPE, is_resource_valid(), ExecutorResourceMgr_Namespace::map_resource_subtype_to_resource_type(), max_resource_grants_per_request_, max_resource_grants_per_request_policies_, and ExecutorResourceMgr_Namespace::UNLIMITED.

Referenced by init().

                                                                  {
   size_t resource_subtype_idx = 0;
   for (auto& max_resource_grant_per_request_policy :
        max_resource_grants_per_request_policies_) {
     const auto resource_subtype = static_cast<ResourceSubtype>(resource_subtype_idx);
     const auto resource_type = map_resource_subtype_to_resource_type(resource_subtype);
     const auto policy_resource_subtype =
         max_resource_grant_per_request_policy.resource_subtype;
     CHECK(resource_subtype == policy_resource_subtype ||
           policy_resource_subtype == ResourceSubtype::INVALID_SUBTYPE);
     if (is_resource_valid(resource_type)) {
       if (policy_resource_subtype == ResourceSubtype::INVALID_SUBTYPE) {
         max_resource_grant_per_request_policy.resource_subtype = resource_subtype;
         max_resource_grant_per_request_policy.policy_size_type =
             ResourceGrantPolicySizeType::UNLIMITED;
       }
       max_resource_grants_per_request_[static_cast<size_t>(
           max_resource_grant_per_request_policy.resource_subtype)] =
           max_resource_grant_per_request_policy.get_grant_quantity(
               get_total_resource(resource_type),
               get_concurrent_resource_grant_policy(resource_type)
                       .oversubscription_concurrency_policy ==
                   ResourceConcurrencyPolicy::DISALLOW_REQUESTS);
     } else {
       max_resource_grant_per_request_policy.resource_subtype =
           ResourceSubtype::INVALID_SUBTYPE;
     }
     resource_subtype_idx++;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ExecutorResourceMgr_Namespace::ExecutorResourcePool::is_resource_valid ( const ResourceType resource_type ) const

inlineprivate

Definition at line 474 of file ExecutorResourcePool.h.

References resource_type_validity_.

Referenced by init_concurrency_policies(), init_max_resource_grants_per_requests(), and log_parameters().

                                                                         {
     return resource_type_validity_[static_cast<size_t>(resource_type)];
   }

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::log_parameters ( ) const

Definition at line 149 of file ExecutorResourcePool.cpp.

References logger::EXECUTOR, get_concurrent_resource_grant_policy(), get_max_resource_grant_per_request_policy(), get_total_resource(), is_resource_valid(), LOG, ExecutorResourceMgr_Namespace::map_resource_type_to_resource_subtypes(), ExecutorResourceMgr_Namespace::resource_type_to_string(), ExecutorResourceMgr_Namespace::ResourceTypeSize, ExecutorResourceMgr_Namespace::ResourceGrantPolicy::to_string(), and ExecutorResourceMgr_Namespace::ConcurrentResourceGrantPolicy::to_string().

Referenced by ExecutorResourcePool().

                                                 {
   for (size_t resource_idx = 0; resource_idx < ResourceTypeSize; ++resource_idx) {
     const ResourceType resource_type = static_cast<ResourceType>(resource_idx);
     if (!is_resource_valid(resource_type)) {
       continue;
     }
     const auto total_resource = get_total_resource(resource_type);
     const auto resource_type_str = resource_type_to_string(resource_type);
     LOG(EXECUTOR) << "Resource: " << resource_type_str << ": " << total_resource;
     LOG(EXECUTOR) << "Concurrency Policy for " << resource_type_str << ": "
                   << get_concurrent_resource_grant_policy(resource_type).to_string();
     LOG(EXECUTOR) << "Max per-request resource grants for sub-types:";
     const auto resource_subtypes = map_resource_type_to_resource_subtypes(resource_type);
     for (const auto& resource_subtype : resource_subtypes) {
       LOG(EXECUTOR)
           << get_max_resource_grant_per_request_policy(resource_subtype).to_string();
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::remove_chunk_requests_from_allocated_pool	(	const ResourceGrant &	resource_grant,
		const ChunkRequestInfo &	chunk_request_info
	)

private

Definition at line 814 of file ExecutorResourcePool.cpp.

Referenced by deallocate_resources().

                                                 {
   // Expects lock on resource_mutex_ already taken
 
   if (resource_grant.buffer_mem_gated_per_slot) {
     CHECK(chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU);
     CHECK_GE(
         get_allocated_resource_of_subtype(ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM),
         resource_grant.buffer_mem_for_given_slots);
     CHECK_GE(
         get_allocated_resource_of_subtype(ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM),
         resource_grant.buffer_mem_for_given_slots);
     allocated_resources_[static_cast<size_t>(
         ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM)] -=
         resource_grant.buffer_mem_for_given_slots;
     const std::string& pool_level_string =
         chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU ? "CPU"
                                                                               : "GPU";
     LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                   << " allocated_temp chunk removal: "
                   << format_num_bytes(resource_grant.buffer_mem_for_given_slots);
     LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                   << " pool state: Transient Allocations: "
                   << format_num_bytes(get_allocated_resource_of_subtype(
                          ResourceSubtype::PAGEABLE_CPU_BUFFER_POOL_MEM))
                   << " Total Allocations: "
                   << format_num_bytes(get_allocated_resource_of_type(
                          ResourceType::CPU_BUFFER_POOL_MEM));
     return;
   }
 
   BufferPoolChunkMap& chunk_map_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? allocated_cpu_buffer_pool_chunks_
           : allocated_gpu_buffer_pool_chunks_;
   size_t& pinned_buffer_mem_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? allocated_resources_[static_cast<size_t>(
                 ResourceSubtype::PINNED_CPU_BUFFER_POOL_MEM)]
           : allocated_resources_[static_cast<size_t>(
                 ResourceSubtype::PINNED_GPU_BUFFER_POOL_MEM)];
 
   // Following variables are for logging
   const size_t pre_remove_allocated_chunks_for_memory_level =
       chunk_map_for_memory_level.size();
   const size_t pre_remove_allocated_buffer_mem_for_memory_level =
       pinned_buffer_mem_for_memory_level;
 
   for (const auto& requested_chunk : chunk_request_info.chunks_with_byte_sizes) {
     auto chunk_itr = chunk_map_for_memory_level.find(requested_chunk.first);
     // Chunk must exist in pool
     CHECK(chunk_itr != chunk_map_for_memory_level.end());
     chunk_itr->second.first -= 1;
     if (chunk_itr->second.first == size_t(0)) {
       pinned_buffer_mem_for_memory_level -= chunk_itr->second.second;
       chunk_map_for_memory_level.erase(chunk_itr);
     }
   }
   const size_t total_buffer_mem_for_memory_level =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU
           ? get_total_resource(ResourceType::CPU_BUFFER_POOL_MEM)
           : get_total_resource(ResourceType::GPU_BUFFER_POOL_MEM);
 
   const size_t post_remove_allocated_chunks_for_memory_level =
       chunk_map_for_memory_level.size();
   const size_t net_removed_allocated_chunks =
       pre_remove_allocated_chunks_for_memory_level -
       post_remove_allocated_chunks_for_memory_level;
   const size_t net_removed_allocated_memory =
       pre_remove_allocated_buffer_mem_for_memory_level -
       pinned_buffer_mem_for_memory_level;
 
   const std::string& pool_level_string =
       chunk_request_info.device_memory_pool_type == ExecutorDeviceType::CPU ? "CPU"
                                                                             : "GPU";
   LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                 << " chunk removal: " << chunk_request_info.num_chunks << " chunks | "
                 << format_num_bytes(chunk_request_info.total_bytes);
   LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                 << " pool delta: " << net_removed_allocated_chunks << " chunks removed | "
                 << format_num_bytes(net_removed_allocated_memory);
   LOG(EXECUTOR) << "ExecutorResourePool " << pool_level_string
                 << " pool state: " << post_remove_allocated_chunks_for_memory_level
                 << " chunks | " << format_num_bytes(pinned_buffer_mem_for_memory_level);
 
   if (ENABLE_DEBUG_PRINTING) {
     debug_print("After chunk removal: ",
                 format_num_bytes(pinned_buffer_mem_for_memory_level) + " of ",
                 format_num_bytes(total_buffer_mem_for_memory_level),
                 ", with ",
                 chunk_map_for_memory_level.size(),
                 " chunks.");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::sanity_check_requests_against_allocations ( ) const

private

Definition at line 1153 of file ExecutorResourcePool.cpp.

References allocated_cpu_buffer_pool_chunks_, allocated_gpu_buffer_pool_chunks_, CHECK, CHECK_EQ, CHECK_LE, ExecutorResourceMgr_Namespace::CPU_BUFFER_POOL_MEM, ExecutorResourceMgr_Namespace::CPU_RESULT_MEM, ExecutorResourceMgr_Namespace::CPU_SLOTS, get_allocated_resource_of_type(), get_outstanding_per_resource_num_requests(), ExecutorResourceMgr_Namespace::GPU_BUFFER_POOL_MEM, ExecutorResourceMgr_Namespace::GPU_SLOTS, outstanding_num_requests_, and total_num_requests_.

Referenced by deallocate_resources().

                                                                            {
   const size_t sum_resource_requests =
       get_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS) +
       get_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS) +
       get_outstanding_per_resource_num_requests(ResourceType::CPU_RESULT_MEM);
 
   CHECK_LE(outstanding_num_requests_, total_num_requests_);
   CHECK_LE(outstanding_num_requests_, sum_resource_requests);
   const bool has_outstanding_resource_requests = sum_resource_requests > 0;
   const bool has_outstanding_num_requests_globally = outstanding_num_requests_ > 0;
   CHECK_EQ(has_outstanding_resource_requests, has_outstanding_num_requests_globally);
 
   CHECK_EQ(get_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS) > 0,
            get_allocated_resource_of_type(ResourceType::CPU_SLOTS) > 0);
   CHECK_LE(get_outstanding_per_resource_num_requests(ResourceType::CPU_SLOTS),
            get_allocated_resource_of_type(ResourceType::CPU_SLOTS));
 
   CHECK_EQ(get_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS) > 0,
            get_allocated_resource_of_type(ResourceType::GPU_SLOTS) > 0);
   CHECK_LE(get_outstanding_per_resource_num_requests(ResourceType::GPU_SLOTS),
            get_allocated_resource_of_type(ResourceType::GPU_SLOTS));
 
   CHECK_EQ(get_outstanding_per_resource_num_requests(ResourceType::CPU_RESULT_MEM) > 0,
            get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM) > 0);
   CHECK_LE(get_outstanding_per_resource_num_requests(ResourceType::CPU_RESULT_MEM),
            get_allocated_resource_of_type(ResourceType::CPU_RESULT_MEM));
 
   CHECK_EQ(
       get_outstanding_per_resource_num_requests(ResourceType::CPU_BUFFER_POOL_MEM) > 0,
       get_allocated_resource_of_type(ResourceType::CPU_BUFFER_POOL_MEM) > 0);
 
   CHECK_EQ(
       get_outstanding_per_resource_num_requests(ResourceType::GPU_BUFFER_POOL_MEM) > 0,
       get_allocated_resource_of_type(ResourceType::GPU_BUFFER_POOL_MEM) > 0);
 
   if (outstanding_num_requests_ == static_cast<size_t>(0)) {
     CHECK_EQ(get_allocated_resource_of_type(ResourceType::CPU_BUFFER_POOL_MEM),
              size_t(0));
     CHECK_EQ(get_allocated_resource_of_type(ResourceType::GPU_BUFFER_POOL_MEM),
              size_t(0));
     CHECK(allocated_cpu_buffer_pool_chunks_.empty());
     CHECK(allocated_gpu_buffer_pool_chunks_.empty());
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::set_concurrent_resource_grant_policy ( const ConcurrentResourceGrantPolicy & concurrent_resource_grant_policy )

Resets the concurrent resource grant policy object, which specifies a ResourceType as well as normal and oversubscription concurrency policies. If pool has outstanding requests, will throw. Responsibility of allowing the pool to empty and preventing concurrent requests while this operation is running is left to the caller (in particular, ExecutorResourceMgr::set_concurent_resource_grant_policy pauses the process queue, which waits until all executing requests are finished before yielding to the caller, before calling this method).

Currently only used for testing, but a SQL interface to live-change concurrency policies for the pool could be added.

Parameters

concurrent_resource_grant_policy - new concurrent resource policy (which encompasses the type of resource)

Definition at line 224 of file ExecutorResourcePool.cpp.

References CHECK, init(), ExecutorResourceMgr_Namespace::INVALID_TYPE, outstanding_num_requests_, and ExecutorResourceMgr_Namespace::ConcurrentResourceGrantPolicy::resource_type.

Referenced by ExecutorResourceMgr_Namespace::ExecutorResourceMgr::set_concurrent_resource_grant_policy().

                                                                            {
   CHECK(concurrent_resource_grant_policy.resource_type != ResourceType::INVALID_TYPE);
   if (outstanding_num_requests_) {
     throw std::runtime_error(
         "Executor Pool must be clear of requests to change resource concurrent resource "
         "grant policies.");
   }
   init({}, {concurrent_resource_grant_policy}, {});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::set_resource	(	const ResourceType	resource_type,
		const size_t	resource_quantity
	)

Sets the quantity of resource_type to resource_quantity. If pool has outstanding requests, will throw. Responsibility of allowing the pool to empty and preventing concurrent requests while this operation is running is left to the caller (in particular, ExecutorResourceMgr::set_resource pauses the process queue, which waits until all executing requests are finished before yielding to the caller, before calling this method).

Currently only used for testing, but a SQL interface to live-change resources available in the pool could be added.

Parameters

resource_type	- type of resource to change the quanity of
resource_quantity	- new quantity of resource for given resource_type

Definition at line 212 of file ExecutorResourcePool.cpp.

References CHECK, init(), ExecutorResourceMgr_Namespace::INVALID_TYPE, and outstanding_num_requests_.

Referenced by ExecutorResourceMgr_Namespace::ExecutorResourceMgr::set_resource().

                                                                         {
   CHECK(resource_type != ResourceType::INVALID_TYPE);
   if (outstanding_num_requests_) {
     throw std::runtime_error(
         "Executor Pool must be clear of requests to change resources available.");
   }
   const std::vector<std::pair<ResourceType, size_t>> total_resources_vec = {
       std::make_pair(resource_type, resource_quantity)};
   init(total_resources_vec, {}, {});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ExecutorResourceMgr_Namespace::ExecutorResourcePool::throw_insufficient_resource_error	(	const ResourceSubtype	resource_subtype,
		const size_t	min_resource_requested
	)		const

private

Definition at line 314 of file ExecutorResourcePool.cpp.

References ExecutorResourceMgr_Namespace::CPU_RESULT_MEM, ExecutorResourceMgr_Namespace::CPU_SLOTS, get_max_resource_grant_per_request(), and ExecutorResourceMgr_Namespace::GPU_SLOTS.

Referenced by calc_static_resource_grant_ranges_for_request().

                                                {
   const size_t max_resource_grant_per_request =
       get_max_resource_grant_per_request(resource_subtype);
 
   switch (resource_subtype) {
     case ResourceSubtype::CPU_SLOTS:
       throw QueryNeedsTooManyCpuSlots(max_resource_grant_per_request,
                                       min_resource_requested);
     case ResourceSubtype::GPU_SLOTS:
       throw QueryNeedsTooManyGpuSlots(max_resource_grant_per_request,
                                       min_resource_requested);
     case ResourceSubtype::CPU_RESULT_MEM:
       throw QueryNeedsTooMuchCpuResultMem(max_resource_grant_per_request,
                                           min_resource_requested);
     default:
       throw std::runtime_error(
           "Insufficient resources for request");  // todo: just placeholder
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BufferPoolChunkMap ExecutorResourceMgr_Namespace::ExecutorResourcePool::allocated_cpu_buffer_pool_chunks_

private

Definition at line 545 of file ExecutorResourcePool.h.

Referenced by add_chunk_requests_to_allocated_pool(), get_chunk_bytes_not_in_pool(), get_requested_chunks_not_in_pool(), get_resource_info(), remove_chunk_requests_from_allocated_pool(), and sanity_check_requests_against_allocations().

BufferPoolChunkMap ExecutorResourceMgr_Namespace::ExecutorResourcePool::allocated_gpu_buffer_pool_chunks_

private

Definition at line 546 of file ExecutorResourcePool.h.

Referenced by add_chunk_requests_to_allocated_pool(), get_chunk_bytes_not_in_pool(), get_requested_chunks_not_in_pool(), get_resource_info(), remove_chunk_requests_from_allocated_pool(), and sanity_check_requests_against_allocations().

std::array<size_t, ResourceSubtypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::allocated_resources_ {}

private

Definition at line 529 of file ExecutorResourcePool.h.

Referenced by add_chunk_requests_to_allocated_pool(), allocate_resources(), deallocate_resources(), get_allocated_resource_of_subtype(), and remove_chunk_requests_from_allocated_pool().

std::array<ConcurrentResourceGrantPolicy, ResourceTypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::concurrent_resource_grant_policies_

private

Definition at line 534 of file ExecutorResourcePool.h.

Referenced by get_concurrent_resource_grant_policy(), init(), and init_concurrency_policies().

std::array<size_t, ResourceSubtypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::max_resource_grants_per_request_ {}

private

Definition at line 532 of file ExecutorResourcePool.h.

Referenced by get_max_resource_grant_per_request(), and init_max_resource_grants_per_requests().

std::array<ResourceGrantPolicy, ResourceSubtypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::max_resource_grants_per_request_policies_ {}

private

Definition at line 531 of file ExecutorResourcePool.h.

Referenced by get_max_resource_grant_per_request_policy(), init(), and init_max_resource_grants_per_requests().

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::outstanding_num_requests_ {0}

private

Definition at line 537 of file ExecutorResourcePool.h.

Referenced by allocate_resources(), can_currently_satisfy_request_impl(), deallocate_resources(), get_resource_info(), sanity_check_requests_against_allocations(), set_concurrent_resource_grant_policy(), and set_resource().

std::array<size_t, ResourceTypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::outstanding_per_resource_num_requests_ {}

private

Definition at line 543 of file ExecutorResourcePool.h.

Referenced by decrement_outstanding_per_resource_num_requests(), get_outstanding_per_resource_num_requests(), and increment_outstanding_per_resource_num_requests().

std::shared_mutex ExecutorResourceMgr_Namespace::ExecutorResourcePool::resource_mutex_

mutableprivate

Definition at line 549 of file ExecutorResourcePool.h.

Referenced by allocate_resources(), can_currently_satisfy_request(), deallocate_resources(), determine_dynamic_resource_grant(), and get_resource_info().

std::array<bool, ResourceTypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::resource_type_validity_

private

Initial value:

{

false}

Definition at line 526 of file ExecutorResourcePool.h.

Referenced by init(), and is_resource_valid().

const bool ExecutorResourceMgr_Namespace::ExecutorResourcePool::sanity_check_pool_state_on_deallocations_ {false}

private

Definition at line 548 of file ExecutorResourcePool.h.

Referenced by deallocate_resources().

size_t ExecutorResourceMgr_Namespace::ExecutorResourcePool::total_num_requests_ {0}

private

Definition at line 536 of file ExecutorResourcePool.h.

Referenced by allocate_resources(), get_resource_info(), and sanity_check_requests_against_allocations().

std::array<size_t, ResourceTypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::total_per_resource_num_requests_ {}

private

Definition at line 540 of file ExecutorResourcePool.h.

Referenced by decrement_total_per_resource_num_requests(), get_total_per_resource_num_requests(), and increment_total_per_resource_num_requests().

std::array<size_t, ResourceTypeSize> ExecutorResourceMgr_Namespace::ExecutorResourcePool::total_resources_ {}

private

Definition at line 525 of file ExecutorResourcePool.h.

Referenced by get_total_resource(), and init().

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExecutorResourceMgr/ExecutorResourcePool.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ExecutorResourceMgr/ExecutorResourcePool.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation