be/src/runtime/initial-reservations.h

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.

#ifndef IMPALA_RUNTIME_INITIAL_RESERVATIONS_H
#define IMPALA_RUNTIME_INITIAL_RESERVATIONS_H

#include "common/status.h"
#include "gen-cpp/Types_types.h" // for TUniqueId
#include "runtime/bufferpool/buffer-pool.h"
#include "runtime/bufferpool/reservation-tracker.h"
#include "util/spinlock.h"

namespace impala {

class ObjectPool;

/**
 * Manages the pool of initial reservations for different nodes in the plan tree.
 * Each plan node and sink claims its initial reservation from here, then returns it when
 * it is done executing. The frontend is responsible for making sure that enough initial
 * reservation is in this pool for all of the concurrent claims.
 */
class InitialReservations {
 public:
  /// 'query_reservation' and 'query_mem_tracker' are the top-level trackers for the
  /// query. This creates trackers for initial reservations under those.
  /// 'initial_reservation_total_claims' is the total of initial reservations that will be
  /// claimed over the lifetime of the query. The total bytes claimed via Claim()
  /// cannot exceed this. Allocated objects are stored in 'obj_pool'.
  InitialReservations(ObjectPool* obj_pool, ReservationTracker* query_reservation,
      MemTracker* query_mem_tracker, int64_t initial_reservation_total_claims);

  /// Initialize the query's pool of initial reservations by acquiring the minimum
  /// reservation required for the query on this host. Fails if the reservation could
  /// not be acquired, e.g. because it would exceed a pool or process limit.
  Status Init(
      const TUniqueId& query_id, int64_t query_min_reservation) WARN_UNUSED_RESULT;

  /// Claim the initial reservation of 'bytes' for 'dst'. Assumes that the transfer will
  /// not violate any reservation limits on 'dst'.
  void Claim(BufferPool::ClientHandle* dst, int64_t bytes);

  /// Return the initial reservation of 'bytes' from 'src'. The reservation is returned
  /// to the pool of reservations if it may be needed to satisfy a subsequent claim or
  /// otherwise is released.
  void Return(BufferPool::ClientHandle* src, int64_t bytes);

  /// Release any reservations held onto by this object.
  void ReleaseResources();

 private:
  // Protects all below members to ensure that the internal state is consistent.
  SpinLock lock_;

  // The pool of initial reservations that Claim() returns reservations from and
  // Return() returns reservations to.
  ReservationTracker initial_reservations_;

  MemTracker* const initial_reservation_mem_tracker_;

  /// The total bytes of additional reservations that we expect to be claimed.
  /// initial_reservations_->GetReservation() <= remaining_initial_reservation_claims_.
  int64_t remaining_initial_reservation_claims_;
};
}

#endif