129 lines
4.1 KiB
C++
129 lines
4.1 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#ifndef OCEANBASE_SQL_OB_MONITOR_INFO_MANAGER_H
|
|
#define OCEANBASE_SQL_OB_MONITOR_INFO_MANAGER_H
|
|
#include "lib/task/ob_timer.h"
|
|
#include "lib/atomic/ob_atomic.h"
|
|
#include "lib/hash/ob_linear_hash_map.h"
|
|
#include "lib/allocator/ob_concurrent_fifo_allocator.h"
|
|
#include "sql/monitor/ob_monitor_info_elimination_task.h"
|
|
#include "observer/mysql/ob_mysql_request_manager.h"
|
|
namespace oceanbase {
|
|
namespace sql {
|
|
struct PlanKey {
|
|
uint64_t hash() const
|
|
{
|
|
uint64_t value = 0;
|
|
value = murmurhash(&plan_id_, sizeof(plan_id_), value);
|
|
value = murmurhash(&addr_, sizeof(addr_), value);
|
|
return value;
|
|
}
|
|
bool operator==(const PlanKey& other) const
|
|
{
|
|
return (plan_id_ == other.plan_id_) && (addr_ == other.addr_);
|
|
}
|
|
int64_t plan_id_;
|
|
common::ObAddr addr_;
|
|
};
|
|
class ObMonitorInfoManager {
|
|
friend class TestMonitorInfoManager_tets_duplicated_Test;
|
|
struct ReclainCond {
|
|
public:
|
|
ReclainCond(int64_t curr_timestamp, int64_t max_remain_interval)
|
|
: curr_timestamp_(curr_timestamp), max_remain_interval_(max_remain_interval)
|
|
{}
|
|
int64_t curr_timestamp_;
|
|
int64_t max_remain_interval_;
|
|
bool operator()(const PlanKey& plan_id, int64_t& execution_time)
|
|
{
|
|
UNUSED(plan_id);
|
|
bool bret = false;
|
|
if (curr_timestamp_ - execution_time < max_remain_interval_) {
|
|
} else {
|
|
bret = true;
|
|
}
|
|
return bret;
|
|
}
|
|
};
|
|
typedef common::ObRaQueue::Ref Ref;
|
|
|
|
public:
|
|
ObMonitorInfoManager();
|
|
~ObMonitorInfoManager();
|
|
int init();
|
|
void destroy();
|
|
int get_by_request_id(int64_t request_id, int64_t& index, ObPhyPlanMonitorInfo*& plan_info, Ref* ref);
|
|
int get_by_index(int64_t index, ObPhyPlanMonitorInfo*& plan_info, Ref* ref);
|
|
int revert(Ref* req)
|
|
{
|
|
slow_query_queue_.revert(req);
|
|
return common::OB_SUCCESS;
|
|
}
|
|
int add_monitor_info(ObPhyPlanMonitorInfo* plan_info);
|
|
int alloc(int64_t request_id, ObPhyPlanMonitorInfo*& plan_info);
|
|
int free(ObPhyPlanMonitorInfo*& plan_info);
|
|
int64_t get_start_index()
|
|
{
|
|
return slow_query_queue_.get_pop_idx();
|
|
}
|
|
int64_t get_size()
|
|
{
|
|
return slow_query_queue_.get_size();
|
|
}
|
|
int64_t get_count()
|
|
{
|
|
return slow_query_queue_.get_size();
|
|
}
|
|
int is_info_nearly_duplicated(const common::ObAddr& addr, int64_t plan_id, bool& is_duplicated);
|
|
void print_memory_size()
|
|
{
|
|
SQL_MONITOR_LOG(INFO,
|
|
"print memory size, ",
|
|
K(get_start_index()),
|
|
K(get_size()),
|
|
K(allocator_.allocated()),
|
|
K(allocator_.hold()),
|
|
K(operator_info_size_));
|
|
}
|
|
int gc();
|
|
static const int64_t OB_MAX_QUEUE_SIZE = 100000;
|
|
static const int64_t MAX_MEMORY_SIZE = 500 * 1024 * 1024L;
|
|
static const int64_t PAGE_SIZE = common::OB_MALLOC_BIG_BLOCK_SIZE;
|
|
static const int64_t OB_BATCH_GC_COUNT = 2000;
|
|
static const int64_t OB_MAX_PUSH_INTERVAL = 10 * 1000 * 1000;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(ObMonitorInfoManager);
|
|
void clear_queue(int64_t limit);
|
|
int reclain_map();
|
|
void set_max_push_interval(int64_t time)
|
|
{
|
|
max_push_interval_ = time;
|
|
}
|
|
|
|
private:
|
|
common::ObConcurrentFIFOAllocator allocator_;
|
|
common::ObRaQueue slow_query_queue_;
|
|
common::ObTimer timer_; // for timing task for cleaning data.
|
|
ObMonitorInfoEliminationTask elimination_task_;
|
|
common::ObLinearHashMap<PlanKey, int64_t> plan_execution_time_map_; // last execution time of plan.
|
|
int64_t max_push_interval_;
|
|
int64_t memory_limit_;
|
|
int64_t operator_info_size_; // the memory of operator_infos_ need stat separately,
|
|
// because it is not alloced from allocator.
|
|
};
|
|
|
|
} // namespace sql
|
|
} // namespace oceanbase
|
|
#endif
|