220 lines
7.5 KiB
C++
220 lines
7.5 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_PLAN_CACHE_OB_I_LIB_CACHE_NODE_
|
|
#define OCEANBASE_SQL_PLAN_CACHE_OB_I_LIB_CACHE_NODE_
|
|
|
|
#include "lib/list/ob_dlist.h"
|
|
#include "lib/lock/ob_spin_rwlock.h"
|
|
#include "lib/lock/ob_tc_rwlock.h"
|
|
#include "lib/stat/ob_latch_define.h"
|
|
#include "sql/plan_cache/ob_lib_cache_register.h"
|
|
#include "sql/plan_cache/ob_plan_cache_util.h"
|
|
|
|
namespace oceanbase
|
|
{
|
|
namespace common
|
|
{
|
|
class ObIAllocator;
|
|
}
|
|
|
|
namespace sql
|
|
{
|
|
class ObPlanCache;
|
|
class ObILibCacheKey;
|
|
class ObILibCacheCtx;
|
|
class ObILibCacheObject;
|
|
|
|
struct StmtStat
|
|
{
|
|
int64_t memory_used_;
|
|
int64_t last_active_timestamp_; // used now
|
|
int64_t execute_average_time_;
|
|
int64_t execute_slowest_time_;
|
|
int64_t execute_slowest_timestamp_;
|
|
int64_t execute_count_; // used now
|
|
int64_t execute_slow_count_;
|
|
int64_t ps_count_;
|
|
bool to_delete_;
|
|
StmtStat()
|
|
: memory_used_(0),
|
|
last_active_timestamp_(0),
|
|
execute_average_time_(0),
|
|
execute_slowest_time_(0),
|
|
execute_slowest_timestamp_(0),
|
|
execute_count_(0),
|
|
execute_slow_count_(0),
|
|
ps_count_(0),
|
|
to_delete_(false)
|
|
{
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
memory_used_ = 0;
|
|
last_active_timestamp_ = 0;
|
|
execute_average_time_ = 0;
|
|
execute_slowest_time_ = 0;
|
|
execute_slowest_timestamp_ = 0;
|
|
execute_count_ = 0;
|
|
execute_slow_count_ = 0;
|
|
ps_count_ = 0;
|
|
to_delete_ = false;
|
|
}
|
|
|
|
double weight()
|
|
{
|
|
int64_t time_interval = common::ObTimeUtility::current_time() - last_active_timestamp_;
|
|
double weight = common::OB_PC_WEIGHT_NUMERATOR / static_cast<double>(time_interval);
|
|
return weight;
|
|
}
|
|
|
|
TO_STRING_KV(K_(memory_used),
|
|
K_(last_active_timestamp),
|
|
K_(execute_average_time),
|
|
K_(execute_slowest_time),
|
|
K_(execute_slowest_timestamp),
|
|
K_(execute_count),
|
|
K_(execute_slow_count),
|
|
K_(ps_count),
|
|
K_(to_delete));
|
|
};
|
|
|
|
typedef ObList<ObILibCacheObject*, ObIAllocator> CacheObjList;
|
|
|
|
// The abstract interface class of library cache node, each object in the ObLibCacheNameSpace
|
|
// enum structure needs to inherit from this interface and implement its own implementation class
|
|
class ObILibCacheNode
|
|
{
|
|
friend class ObLCNodeFactory;
|
|
public:
|
|
ObILibCacheNode(ObPlanCache *lib_cache, lib::MemoryContext &mem_context)
|
|
: mem_context_(mem_context),
|
|
allocator_(mem_context->get_safe_arena_allocator()),
|
|
rwlock_(),
|
|
ref_count_(0),
|
|
lib_cache_(lib_cache),
|
|
co_list_lock_(common::ObLatchIds::PLAN_SET_LOCK),
|
|
co_list_(allocator_)
|
|
{
|
|
lock_timeout_ts_ = GCONF.large_query_threshold;
|
|
}
|
|
virtual ~ObILibCacheNode();
|
|
/**
|
|
* @brief initialize library cache node
|
|
* @param cache_obj[in], object that need to be cached
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
virtual int init(ObILibCacheCtx &ctx, const ObILibCacheObject *cache_obj);
|
|
/**
|
|
* @brief decrease the reference count of all cache objects in the library cache value by one
|
|
*/
|
|
void free_cache_obj_array();
|
|
/**
|
|
* @brief remove all plan stat from all cache objects in the library cache node
|
|
*/
|
|
int remove_all_plan_stat();
|
|
/**
|
|
* @brief remove cache obj from cache_obj_list_
|
|
* @param obj_id[in], obj id to remove
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
int remove_cache_obj_entry(const ObCacheObjID obj_id);
|
|
/**
|
|
* @brief get cache object from library cache
|
|
* @param ctx[in], library cache context
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
|
|
int get_cache_obj(ObILibCacheCtx &ctx, ObILibCacheKey *key, ObILibCacheObject *&cache_obj);
|
|
/**
|
|
* @brief add cache object to library cache
|
|
* @param ctx[in], library cache context
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
int add_cache_obj(ObILibCacheCtx &ctx, ObILibCacheKey *key, ObILibCacheObject *cache_obj);
|
|
/**
|
|
* @brief erase cache object from library cache
|
|
* @param ctx[in], library cache context
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
//int erase_cache_obj(ObILibCacheCtx &context, ObILibCacheObject *cache_obj);
|
|
virtual int lock(bool is_rdlock);
|
|
virtual int update_node_stat(ObILibCacheCtx &ctx);
|
|
StmtStat *get_node_stat() { return &node_stat_; }
|
|
int unlock() { return rwlock_.unlock(); }
|
|
int64_t inc_ref_count(const CacheRefHandleID ref_handle);
|
|
int64_t dec_ref_count(const CacheRefHandleID ref_handle);
|
|
int64_t get_ref_count() const { return ATOMIC_LOAD(&ref_count_); }
|
|
common::ObIAllocator *get_allocator() { return &allocator_; }
|
|
common::ObIAllocator &get_allocator_ref() { return allocator_; }
|
|
lib::MemoryContext &get_mem_context() { return mem_context_; }
|
|
int64_t get_mem_size();
|
|
ObPlanCache *get_lib_cache() const { return lib_cache_; }
|
|
|
|
VIRTUAL_TO_STRING_KV(K_(ref_count), K_(lock_timeout_ts));
|
|
|
|
protected:
|
|
void set_lock_timeout_threshold(int64_t threshold)
|
|
{
|
|
lock_timeout_ts_ = threshold;
|
|
}
|
|
/**
|
|
* @brief called by get_cache_obj(), each object in the ObLibCacheNameSpace enumeration structure
|
|
* needs to inherit this interface and implement its own inner get implementation
|
|
* @param ctx[in], library cache context
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
virtual int inner_get_cache_obj(ObILibCacheCtx &ctx,
|
|
ObILibCacheKey *key,
|
|
ObILibCacheObject *&cache_obj) = 0;
|
|
/**
|
|
* @brief called by add_cache_obj(), each object in the ObLibCacheNameSpace enumeration structure
|
|
* needs to inherit this interface and implement its own inner add implementation
|
|
* @param ctx[in], library cache context
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
virtual int inner_add_cache_obj(ObILibCacheCtx &ctx,
|
|
ObILibCacheKey *key,
|
|
ObILibCacheObject *cache_obj) = 0;
|
|
/**
|
|
* @brief called by erase_cache_obj(), each object in the ObLibCacheNameSpace enumeration structure
|
|
* needs to inherit this interface and implement its own inner erase implementation
|
|
* @param ctx[in], library cache context
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
//int inner_erase_cache_obj(ObILibCacheCtx &ctx, ObILibCacheObject *cache_obj) = 0;
|
|
/**
|
|
* @brief called to do something before cache evicted
|
|
* @return if success, return OB_SUCCESS, otherwise, return errno
|
|
*/
|
|
virtual int before_cache_evicted();
|
|
|
|
protected:
|
|
lib::MemoryContext mem_context_;
|
|
// Note: all memory allocations in ObILibCacheNode can only use allocator_, when the ObILibCacheNode
|
|
// node is destructed, all memory allocated by allocator_ will be released
|
|
common::ObIAllocator &allocator_;
|
|
common::TCRWLock rwlock_;
|
|
int64_t ref_count_;
|
|
int64_t lock_timeout_ts_;
|
|
StmtStat node_stat_;
|
|
ObPlanCache *lib_cache_;
|
|
common::SpinRWLock co_list_lock_;
|
|
CacheObjList co_list_;
|
|
};
|
|
|
|
} // namespace common
|
|
} // namespace oceanbase
|
|
|
|
#endif // OCEANBASE_SQL_PLAN_CACHE_OB_I_LIB_CACHE_NODE_
|