mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-12-13 18:02:24 +00:00
90 lines
2.7 KiB
C++
90 lines
2.7 KiB
C++
#pragma once
|
|
|
|
#include <base/types.h>
|
|
#include <limits>
|
|
|
|
namespace DB
|
|
{
|
|
|
|
// Forward declarations
|
|
class ISchedulerQueue;
|
|
class ISchedulerConstraint;
|
|
|
|
/// Cost in terms of used resource (e.g. bytes for network IO)
|
|
using ResourceCost = Int64;
|
|
constexpr ResourceCost ResourceCostMax = std::numeric_limits<int>::max();
|
|
|
|
/// Timestamps (nanoseconds since epoch)
|
|
using ResourceNs = UInt64;
|
|
|
|
/*
|
|
* Request for a resource consumption. The main moving part of the scheduling subsystem.
|
|
* Resource requests processing workflow:
|
|
*
|
|
* ----1=2222222222222=3=4=555555555555555=6-----> time
|
|
* ^ ^ ^ ^ ^ ^
|
|
* | | | | | |
|
|
* enqueue wait dequeue execute consume finish
|
|
*
|
|
* 1) Request is enqueued using ISchedulerQueue::enqueueRequest().
|
|
* 2) Request competes with others for access to a resource; effectively just waiting in a queue.
|
|
* 3) Scheduler calls ISchedulerNode::dequeueRequest() that returns the request.
|
|
* 4) Callback ResourceRequest::execute() is called to provide access to the resource.
|
|
* 5) The resource consumption is happening outside of the scheduling subsystem.
|
|
* 6) request->constraint->finishRequest() is called when consumption is finished.
|
|
*
|
|
* Steps (5) and (6) can be omitted if constraint is not used by the resource.
|
|
*
|
|
* Request can be created on stack or heap.
|
|
* Request ownership is done outside of the scheduling subsystem.
|
|
* After (6) request can be destructed safely.
|
|
*
|
|
* Request cancelling is not supported yet.
|
|
*/
|
|
class ResourceRequest
|
|
{
|
|
public:
|
|
/// Cost of request execution; should be filled before request enqueueing.
|
|
/// NOTE: If cost is not known in advance, credit model can be used:
|
|
/// NOTE: for the first request use 1 and
|
|
ResourceCost cost;
|
|
|
|
/// Request outcome
|
|
/// Should be filled during resource consumption
|
|
bool successful;
|
|
|
|
/// Scheduler node to be notified on consumption finish
|
|
/// Auto-filled during request enqueue/dequeue
|
|
ISchedulerConstraint * constraint;
|
|
|
|
/// Timestamps for introspection
|
|
ResourceNs enqueue_ns;
|
|
ResourceNs execute_ns;
|
|
ResourceNs finish_ns;
|
|
|
|
explicit ResourceRequest(ResourceCost cost_ = 1)
|
|
{
|
|
reset(cost_);
|
|
}
|
|
|
|
void reset(ResourceCost cost_)
|
|
{
|
|
cost = cost_;
|
|
successful = true;
|
|
constraint = nullptr;
|
|
enqueue_ns = 0;
|
|
execute_ns = 0;
|
|
finish_ns = 0;
|
|
}
|
|
|
|
virtual ~ResourceRequest() = default;
|
|
|
|
/// Callback to trigger resource consumption.
|
|
/// IMPORTANT: it is called from scheduler thread and must be fast,
|
|
/// just triggering start of a consumption, not doing the consumption itself
|
|
/// (e.g. setting an std::promise or creating a job in a thread pool)
|
|
virtual void execute() = 0;
|
|
};
|
|
|
|
}
|