ResourceGrantPolicy.h

Go to the documentation of this file.

/*
 * Copyright 2022 HEAVY.AI, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include "ExecutorResourceMgrCommon.h"

namespace ExecutorResourceMgr_Namespace {

enum ResourceGrantPolicySizeType { UNLIMITED, CONSTANT, RATIO_TO_TOTAL };

union ResourceGrantSizeInfo {
  size_t constant;
  double ratio_to_total;
  ResourceGrantSizeInfo() : constant(0) {}
  ResourceGrantSizeInfo(const size_t constant) : constant(constant) {}
  ResourceGrantSizeInfo(const double ratio_to_total) : ratio_to_total(ratio_to_total) {}
};

struct ResourceGrantPolicy {
  ResourceSubtype resource_subtype{ResourceSubtype::INVALID_SUBTYPE};
  ResourceGrantPolicySizeType policy_size_type{ResourceGrantPolicySizeType::CONSTANT};
  ResourceGrantSizeInfo size_info;

  ResourceGrantPolicy() {}

  ResourceGrantPolicy(const ResourceSubtype resource_subtype,
                      const ResourceGrantPolicySizeType policy_size_type,
                      const ResourceGrantSizeInfo size_info);

  size_t get_grant_quantity(const size_t total_resource_quantity) const;

  size_t get_grant_quantity(const size_t total_resource_quantity,
                            const bool cap_at_total_available) const;

  std::string to_string() const;
};

ResourceGrantPolicy gen_unlimited_resource_grant_policy(
    const ResourceSubtype resource_subtype);

ResourceGrantPolicy gen_constant_resource_grant_policy(
    const ResourceSubtype resource_subtype,
    size_t constant_grant);

ResourceGrantPolicy gen_ratio_resource_grant_policy(
    const ResourceSubtype resource_subtype,
    const double ratio_grant);

enum ResourceConcurrencyPolicy {
  ALLOW_CONCURRENT_REQUESTS,
  ALLOW_SINGLE_REQUEST,
  ALLOW_SINGLE_REQUEST_GLOBALLY,
  DISALLOW_REQUESTS
};

std::string get_resouce_concurrency_policy_string(
    const ResourceConcurrencyPolicy& resource_concurrency_policy);

struct ConcurrentResourceGrantPolicy {
  ResourceType resource_type{ResourceType::INVALID_TYPE};

  ResourceConcurrencyPolicy concurrency_policy{DISALLOW_REQUESTS};

  ResourceConcurrencyPolicy oversubscription_concurrency_policy{DISALLOW_REQUESTS};

  ConcurrentResourceGrantPolicy() {}

  ConcurrentResourceGrantPolicy(
      const ResourceType resource_type,
      const ResourceConcurrencyPolicy concurrency_policy,
      const ResourceConcurrencyPolicy oversubscription_concurrency_policy)
      : resource_type(resource_type)
      , concurrency_policy(concurrency_policy)
      , oversubscription_concurrency_policy(oversubscription_concurrency_policy) {}

  bool operator==(const ConcurrentResourceGrantPolicy& rhs) const;

  std::string to_string() const;
};

}  // namespace ExecutorResourceMgr_Namespace