File vacuum.c¶

FileList > cubrid > src > query > vacuum.c

#include <inttypes.h>
#include "system.h"
#include "vacuum.h"
#include "base_flag.hpp"
#include "boot_sr.h"
#include "btree.h"
#include "dbtype.h"
#include "heap_file.h"
#include "lockfree_circular_queue.hpp"
#include "log_append.hpp"
#include "log_compress.h"
#include "log_lsa.hpp"
#include "log_impl.h"
#include "log_reader.hpp"
#include "mvcc.h"
#include "mvcc_table.hpp"
#include "object_representation.h"
#include "object_representation_sr.h"
#include "overflow_file.h"
#include "page_buffer.h"
#include "perf_monitor.h"
#include "resource_shared_pool.hpp"
#include "thread_entry_task.hpp"
#include "thread_daemon.hpp"
#include "thread_looper.hpp"
#include "thread_manager.hpp"
#include "thread_worker_pool_impl.hpp"
#include "monitor_vacuum_ovfp_threshold.hpp"
#include "util_func.h"
#include <atomic>
#include <condition_variable>
#include <mutex>
#include <stack>
#include <cstring>
#include "memory_wrapper.hpp"

Classes¶

Type	Name
struct	vacuum_data
struct	vacuum_data_entry
struct	vacuum_data_load
struct	vacuum_data_page
struct	vacuum_dropped_file
struct	vacuum_dropped_files_page
struct	vacuum_dropped_files_rcv_data
struct	vacuum_heap_helper
class	vacuum_job_cursor
class	vacuum_master_entry_manager
class	vacuum_master_task
class	vacuum_shutdown_sequence
struct	vacuum_track_dropped_files
class	vacuum_worker_entry_manager
class	vacuum_worker_task

Public Types¶

Type	Name
typedef struct vacuum_data	VACUUM_DATA
typedef struct vacuum_data_entry	VACUUM_DATA_ENTRY
typedef struct vacuum_data_load	VACUUM_DATA_LOAD
typedef struct vacuum_data_page	VACUUM_DATA_PAGE
typedef struct vacuum_dropped_file	VACUUM_DROPPED_FILE
typedef struct vacuum_dropped_files_page	VACUUM_DROPPED_FILES_PAGE
typedef struct vacuum_dropped_files_rcv_data	VACUUM_DROPPED_FILES_RCV_DATA
typedef struct vacuum_heap_helper	VACUUM_HEAP_HELPER
typedef struct vacuum_track_dropped_files	VACUUM_TRACK_DROPPED_FILES

Public Attributes¶

Type	Name
class ovfp_threshold_mgr	g_ovfp_threshold_mgr
lockfree::circular_queue< vacuum_data_entry > *	vacuum_Block_data_buffer = `[NULL](freelistheap_8h.md#define-null)`
VACUUM_DATA_LOAD	vacuum_Data_load = `{ [VPID\_INITIALIZER](dbtype__def_8h.md#define-vpid_initializer), [VPID\_INITIALIZER](dbtype__def_8h.md#define-vpid_initializer) }`
pthread_mutex_t	vacuum_Dropped_files_mutex
INT32	vacuum_Dropped_files_version = `0`
lockfree::circular_queue< VACUUM_LOG_BLOCKID > *	vacuum_Finished_job_queue = `[NULL](freelistheap_8h.md#define-null)`
bool	vacuum_Is_booted = `[false](broker__monitor_8c.md#function-timeout)`
VFID	vacuum_Last_dropped_vfid
VACUUM_WORKER	vacuum_Master
VACUUM_TRACK_DROPPED_FILES *	vacuum_Track_dropped_files
VACUUM_WORKER	vacuum_Workers

Public Static Attributes¶

Type	Name
VACUUM_DATA	vacuum_Data
INT32	vacuum_Dropped_files_count = `0`
bool	vacuum_Dropped_files_loaded = `[false](broker__monitor_8c.md#function-timeout)`
VFID	vacuum_Dropped_files_vfid
VPID	vacuum_Dropped_files_vpid
cubthread::daemon *	vacuum_Master_daemon = `[NULL](freelistheap_8h.md#define-null)`
vacuum_master_entry_manager *	vacuum_Master_entry_manager = `[NULL](freelistheap_8h.md#define-null)`
vacuum_worker_entry_manager *	vacuum_Worker_entry_manager = `[NULL](freelistheap_8h.md#define-null)`
cubthread::stats_worker_pool_type *	vacuum_Worker_threads = `[NULL](freelistheap_8h.md#define-null)`

Public Functions¶

Type	Name
	REGISTER_DAEMON (vacuum)
	REGISTER_WORKERPOOL (vacuum, () { return prm_get_integer_value(PRM_ID_VACUUM_WORKER_COUNT);})
int	vacuum_boot (THREAD_ENTRY * thread_p)
DISK_ISVALID	vacuum_check_not_vacuumed_rec_header (THREAD_ENTRY * thread_p, OID * oid, OID * class_oid, MVCC_REC_HEADER * rec_header, int btree_node_type)
DISK_ISVALID	vacuum_check_not_vacuumed_recdes (THREAD_ENTRY * thread_p, OID * oid, OID * class_oid, RECDES * recdes, int btree_node_type)
int	vacuum_consume_buffer_log_blocks (THREAD_ENTRY * thread_p)
int	vacuum_create_file_for_dropped_files (THREAD_ENTRY * thread_p, VFID * dropped_files_vfid)
int	vacuum_create_file_for_vacuum_data (THREAD_ENTRY * thread_p, VFID * vacuum_data_vfid)
int	vacuum_data_load_and_recover (THREAD_ENTRY * thread_p)
void	vacuum_finalize (THREAD_ENTRY * thread_p)
VACUUM_LOG_BLOCKID	vacuum_get_log_blockid (LOG_PAGEID pageid)
int	vacuum_heap_page (THREAD_ENTRY * thread_p, VACUUM_HEAP_OBJECT * heap_objects, int n_heap_objects, MVCCID threshold_mvccid, HFID * hfid, bool * reusable, bool was_interrupted)
void	vacuum_init_thread_context (cubthread::entry & context, thread_type type, VACUUM_WORKER * worker)
int	vacuum_initialize (THREAD_ENTRY * thread_p, int vacuum_log_block_npages, VFID * vacuum_data_vfid, VFID * dropped_files_vfid, bool is_restore)
int	vacuum_is_file_dropped (THREAD_ENTRY * thread_p, bool * is_file_dropped, VFID * vfid, MVCCID mvccid)
bool	vacuum_is_mvccid_vacuumed (MVCCID id)
bool	vacuum_is_safe_to_remove_archives (void)
int	vacuum_load_dropped_files_from_disk (THREAD_ENTRY * thread_p)
void	vacuum_log_add_dropped_file (THREAD_ENTRY * thread_p, const VFID * vfid, const OID * class_oid, bool pospone_or_undo)
LOG_PAGEID	vacuum_min_log_pageid_to_keep (THREAD_ENTRY * thread_p)
void	vacuum_notify_es_deleted (THREAD_ENTRY * thread_p, const char * uri)
void	vacuum_notify_server_crashed (LOG_LSA * recovery_lsa)
void	vacuum_notify_server_shutdown (void)
void	vacuum_produce_log_block_data (THREAD_ENTRY * thread_p)
int	vacuum_reset_data_after_copydb (THREAD_ENTRY * thread_p)
int	vacuum_rv_check_at_undo (THREAD_ENTRY * thread_p, PAGE_PTR pgptr, INT16 slotid, INT16 rec_type)
int	vacuum_rv_es_nop (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_notify_dropped_file (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_add_dropped_file (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_append_data (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
void	vacuum_rv_redo_append_data_dump (FILE * fp, int length, void * data)
int	vacuum_rv_redo_cleanup_dropped_files (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_data_finished (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
void	vacuum_rv_redo_data_finished_dump (FILE * fp, int length, void * data)
int	vacuum_rv_redo_initialize_data_page (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_remove_ovf_insid (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_start_job (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_vacuum_complete (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_vacuum_heap_page (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_redo_vacuum_heap_record (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_replace_dropped_file (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_set_next_page_dropped_files (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_undo_add_dropped_file (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_undo_vacuum_heap_record (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
int	vacuum_rv_undoredo_data_set_link (THREAD_ENTRY * thread_p, LOG_RCV * rcv)
void	vacuum_rv_undoredo_data_set_link_dump (FILE * fp, int length, void * data)
void	vacuum_sa_reflect_last_blockid (THREAD_ENTRY * thread_p)
void	vacuum_stop_master (THREAD_ENTRY * thread_p)
void	vacuum_stop_workers (THREAD_ENTRY * thread_p)
int	xvacuum (THREAD_ENTRY * thread_p)
void	xvacuum_dump (THREAD_ENTRY * thread_p, FILE * outfp)

Public Static Functions¶

Type	Name
bool	is_not_vacuumed_and_lost (THREAD_ENTRY * thread_p, MVCC_REC_HEADER * rec_header)
void	print_not_vacuumed_to_log (OID * oid, OID * class_oid, MVCC_REC_HEADER * rec_header, int btree_node_type)
int	vacuum_add_dropped_file (THREAD_ENTRY * thread_p, VFID * vfid, MVCCID mvccid)
void	vacuum_check_shutdown_interruption (const THREAD_ENTRY * thread_p, int error_code)
void	vacuum_cleanup_collected_by_vfid (VACUUM_WORKER * worker, VFID * vfid)
int	vacuum_cleanup_dropped_files (THREAD_ENTRY * thread_p)
int	vacuum_collect_heap_objects (THREAD_ENTRY * thread_p, VACUUM_WORKER * worker, OID * oid, VFID * vfid)
int	vacuum_compare_blockids (const void * ptr1, const void * ptr2)
int	vacuum_compare_dropped_files (const void * a, const void * b)
int	vacuum_compare_dropped_files_version (INT32 version_a, INT32 version_b)
int	vacuum_compare_heap_object (const void * a, const void * b)
void	vacuum_convert_thread_to_master (THREAD_ENTRY * thread_p, thread_type & save_type)
void	vacuum_convert_thread_to_worker (THREAD_ENTRY * thread_p, VACUUM_WORKER * worker, thread_type & save_type)
void	vacuum_copy_data_from_log (THREAD_ENTRY * thread_p, char * area, int length, LOG_LSA * log_lsa, LOG_PAGE * log_page)
void	vacuum_data_empty_page (THREAD_ENTRY * thread_p, VACUUM_DATA_PAGE * prev_data_page, VACUUM_DATA_PAGE ** data_page)
void	vacuum_data_empty_update_last_blockid (THREAD_ENTRY * thread_p)
void	vacuum_data_initialize_new_page (THREAD_ENTRY * thread_p, VACUUM_DATA_PAGE * data_page)
void	vacuum_data_load_first_and_last_page (THREAD_ENTRY * thread_p)
int	vacuum_data_mark_finished (THREAD_ENTRY * thread_p)
void	vacuum_data_unload_first_and_last_page (THREAD_ENTRY * thread_p)
void	vacuum_dropped_files_set_next_page (THREAD_ENTRY * thread_p, VACUUM_DROPPED_FILES_PAGE * page_p, VPID * next_page)
int	vacuum_fetch_log_page (THREAD_ENTRY * thread_p, LOG_PAGEID log_pageid, LOG_PAGE * log_page)
void	vacuum_finalize_worker (THREAD_ENTRY * thread_p, VACUUM_WORKER * worker_info)
int	vacuum_find_dropped_file (THREAD_ENTRY * thread_p, bool * is_file_dropped, VFID * vfid, MVCCID mvccid)
void	vacuum_finished_block_vacuum (THREAD_ENTRY * thread_p, VACUUM_DATA_ENTRY * block_data, bool is_vacuum_complete)
int	vacuum_get_first_page_dropped_files (THREAD_ENTRY * thread_p, VPID * first_page_vpid)
INT32	vacuum_get_worker_min_dropped_files_version (void)
int	vacuum_heap (THREAD_ENTRY * thread_p, VACUUM_WORKER * worker, MVCCID threshold_mvccid, bool was_interrupted)
int	vacuum_heap_get_hfid_and_file_type (THREAD_ENTRY * thread_p, VACUUM_HEAP_HELPER * helper, const VFID * vfid)
void	vacuum_heap_page_log_and_reset (THREAD_ENTRY * thread_p, VACUUM_HEAP_HELPER * helper, bool update_best_space_stat, bool unlatch_page)
int	vacuum_heap_prepare_record (THREAD_ENTRY * thread_p, VACUUM_HEAP_HELPER * helper)
int	vacuum_heap_record (THREAD_ENTRY * thread_p, VACUUM_HEAP_HELPER * helper)
int	vacuum_heap_record_insid_and_prev_version (THREAD_ENTRY * thread_p, VACUUM_HEAP_HELPER * helper)
void	vacuum_init_data_page_with_last_blockid (THREAD_ENTRY * thread_p, VACUUM_DATA_PAGE * data_page, VACUUM_LOG_BLOCKID blockid)
bool	vacuum_is_empty (void)
bool	vacuum_is_work_in_progress (THREAD_ENTRY * thread_p)
void	vacuum_log_cleanup_dropped_files (THREAD_ENTRY * thread_p, PAGE_PTR page_p, INT16 * indexes, INT16 n_indexes)
int	vacuum_log_prefetch_vacuum_block (THREAD_ENTRY * thread_p, VACUUM_DATA_ENTRY * entry)
void	vacuum_log_redoundo_vacuum_record (THREAD_ENTRY * thread_p, PAGE_PTR page_p, PGSLOTID slotid, RECDES * undo_recdes, bool reusable)
void	vacuum_log_remove_ovf_insid (THREAD_ENTRY * thread_p, PAGE_PTR ovfpage)
void	vacuum_log_vacuum_heap_page (THREAD_ENTRY * thread_p, PAGE_PTR page_p, int n_slots, PGSLOTID * slots, MVCC_SATISFIES_VACUUM_RESULT * results, bool reusable, bool all_vacuumed)
void	vacuum_notify_all_workers_dropped_file (const VFID & vfid_dropped, MVCCID mvccid)
int	vacuum_process_log_block (THREAD_ENTRY * thread_p, VACUUM_DATA_ENTRY * block_data, bool sa_mode_partial_block)
int	vacuum_process_log_record (THREAD_ENTRY * thread_p, VACUUM_WORKER * worker, LOG_LSA * log_lsa_p, LOG_PAGE * log_page_p, LOG_DATA * log_record_data, MVCCID * mvccid, char undo_data_ptr, int** * undo_data_size, LOG_VACUUM_INFO * vacuum_info, bool * is_file_dropped, bool stop_after_vacuum_info)
void	vacuum_read_advance_when_doesnt_fit (THREAD_ENTRY * thread_entry, size_t size, LOG_LSA * log_lsa, LOG_PAGE * log_page)
void	vacuum_read_log_add_aligned (THREAD_ENTRY * thread_entry, size_t size, LOG_LSA * log_lsa, LOG_PAGE * log_page)
void	vacuum_read_log_aligned (THREAD_ENTRY * thread_entry, LOG_LSA * log_lsa, LOG_PAGE * log_page)
int	vacuum_recover_lost_block_data (THREAD_ENTRY * thread_p)
void	vacuum_restore_thread (THREAD_ENTRY * thread_p, thread_type save_type)
void	vacuum_sa_run_job (THREAD_ENTRY * thread_p, const VACUUM_DATA_ENTRY & data_entry, bool is_partial, PERF_UTIME_TRACKER & perf_tracker)
void	vacuum_set_dirty_data_page (cubthread::entry * thread_p, vacuum_data_page * data_page, bool free)
void	vacuum_set_dirty_data_page_dont_free (cubthread::entry * thread_p, vacuum_data_page * data_page)
void	vacuum_update_keep_from_log_pageid (THREAD_ENTRY * thread_p)
void	vacuum_verify_vacuum_data_debug (THREAD_ENTRY * thread_p)
void	vacuum_verify_vacuum_data_page_fix_count (THREAD_ENTRY * thread_p)
int	vacuum_worker_allocate_resources (THREAD_ENTRY * thread_p, VACUUM_WORKER * worker)

Macros¶

Type	Name
define	ES_NOTIFY_VACUUM_FOR_DELETE_BUFFER_SIZE `/* multi line expression */`
define	MAX_PAGE_MAX_DATA_ENTRIES `([IO\_MAX\_PAGE\_SIZE](storage__common_8h.md#define-io_max_page_size) / [sizeof](broker__monitor_8c.md#function-timeout) ([VACUUM\_DATA\_ENTRY](vacuum_8c.md#typedef-vacuum_data_entry)))`
define	MAX_SLOTS_IN_PAGE `([IO\_MAX\_PAGE\_SIZE](storage__common_8h.md#define-io_max_page_size) / [sizeof](broker__monitor_8c.md#function-timeout) ([SPAGE\_SLOT](slotted__page_8h.md#typedef-spage_slot)))`
define	TEMP_BUFFER_SIZE `[VACUUM\_FINISHED\_JOB\_QUEUE\_CAPACITY](vacuum_8c.md#define-vacuum_finished_job_queue_capacity)`
define	TEMP_BUFFER_SIZE `[VACUUM\_FINISHED\_JOB\_QUEUE\_CAPACITY](vacuum_8c.md#define-vacuum_finished_job_queue_capacity)`
define	VACUUM_BLOCKID_GET_FLAGS (blockid) `((blockid) & [VACUUM\_DATA\_ENTRY\_FLAG\_MASK](vacuum_8c.md#define-vacuum_data_entry_flag_mask))`
define	VACUUM_BLOCKID_WITHOUT_FLAGS (blockid) `((blockid) & [VACUUM\_DATA\_ENTRY\_BLOCKID\_MASK](vacuum_8c.md#define-vacuum_data_entry_blockid_mask))`
define	VACUUM_BLOCK_CLEAR_INTERRUPTED (blockid) `((blockid) &= ~[VACUUM\_BLOCK\_FLAG\_INTERRUPTED](vacuum_8c.md#define-vacuum_block_flag_interrupted))`
define	VACUUM_BLOCK_DATA_BUFFER_CAPACITY `1024`
define	VACUUM_BLOCK_FLAG_INTERRUPTED `0x2000000000000000`
define	VACUUM_BLOCK_IS_INTERRUPTED (blockid) `(((blockid) & [VACUUM\_BLOCK\_FLAG\_INTERRUPTED](vacuum_8c.md#define-vacuum_block_flag_interrupted)) != 0)`
define	VACUUM_BLOCK_SET_INTERRUPTED (blockid) `((blockid) \\|= [VACUUM\_BLOCK\_FLAG\_INTERRUPTED](vacuum_8c.md#define-vacuum_block_flag_interrupted))`
define	VACUUM_BLOCK_STATUS (blockid) `((blockid) & [VACUUM\_BLOCK\_STATUS\_MASK](vacuum_8c.md#define-vacuum_block_status_mask))`
define	VACUUM_BLOCK_STATUS_AVAILABLE `0x0000000000000000`
define	VACUUM_BLOCK_STATUS_IN_PROGRESS_VACUUM `0x4000000000000000`
define	VACUUM_BLOCK_STATUS_IS_AVAILABLE (blockid) `([VACUUM\_BLOCK\_STATUS](vacuum_8c.md#define-vacuum_block_status) (blockid) == [VACUUM\_BLOCK\_STATUS\_AVAILABLE](vacuum_8c.md#define-vacuum_block_status_available))`
define	VACUUM_BLOCK_STATUS_IS_IN_PROGRESS (blockid) `([VACUUM\_BLOCK\_STATUS](vacuum_8c.md#define-vacuum_block_status) (blockid) == [VACUUM\_BLOCK\_STATUS\_IN\_PROGRESS\_VACUUM](vacuum_8c.md#define-vacuum_block_status_in_progress_vacuum))`
define	VACUUM_BLOCK_STATUS_IS_VACUUMED (blockid) `([VACUUM\_BLOCK\_STATUS](vacuum_8c.md#define-vacuum_block_status) (blockid) == [VACUUM\_BLOCK\_STATUS\_VACUUMED](vacuum_8c.md#define-vacuum_block_status_vacuumed))`
define	VACUUM_BLOCK_STATUS_MASK `0xC000000000000000`
define	VACUUM_BLOCK_STATUS_SET_AVAILABLE (blockid) `((blockid) = ((blockid) & ~[VACUUM\_BLOCK\_STATUS\_MASK](vacuum_8c.md#define-vacuum_block_status_mask)) \\| [VACUUM\_BLOCK\_STATUS\_AVAILABLE](vacuum_8c.md#define-vacuum_block_status_available))`
define	VACUUM_BLOCK_STATUS_SET_IN_PROGRESS (blockid) `((blockid) = ((blockid) & ~[VACUUM\_BLOCK\_STATUS\_MASK](vacuum_8c.md#define-vacuum_block_status_mask)) \\| [VACUUM\_BLOCK\_STATUS\_IN\_PROGRESS\_VACUUM](vacuum_8c.md#define-vacuum_block_status_in_progress_vacuum))`
define	VACUUM_BLOCK_STATUS_SET_VACUUMED (blockid) `((blockid) = ((blockid) & ~[VACUUM\_BLOCK\_STATUS\_MASK](vacuum_8c.md#define-vacuum_block_status_mask)) \\| [VACUUM\_BLOCK\_STATUS\_VACUUMED](vacuum_8c.md#define-vacuum_block_status_vacuumed))`
define	VACUUM_BLOCK_STATUS_VACUUMED `0x8000000000000000`
define	VACUUM_CLEANUP_DROPPED_FILES_MAX_REDO_CRUMBS `3`
define	VACUUM_DATA_ENTRY_BLOCKID_MASK `0x1FFFFFFFFFFFFFFF`
define	VACUUM_DATA_ENTRY_FLAG_MASK `0xE000000000000000`
define	VACUUM_DATA_PAGE_HEADER_SIZE `([offsetof](broker__monitor_8c.md#function-timeout) ([VACUUM\_DATA\_PAGE](vacuum_8c.md#typedef-vacuum_data_page), data))`
define	VACUUM_DEFAULT_HEAP_OBJECT_BUFFER_SIZE `4000`
define	VACUUM_DROPPED_FILES_MAX_PAGE_CAPACITY `/* multi line expression */`
define	VACUUM_DROPPED_FILES_PAGE_CAPACITY `/* multi line expression */`
define	VACUUM_DROPPED_FILES_PAGE_HEADER_SIZE `([offsetof](broker__monitor_8c.md#function-timeout) ([VACUUM\_DROPPED\_FILES\_PAGE](vacuum_8c.md#typedef-vacuum_dropped_files_page), dropped\_files))`
define	VACUUM_DROPPED_FILE_FLAG_DUPLICATE `0x8000`
define	VACUUM_FINISHED_JOB_QUEUE_CAPACITY `2048`
define	VACUUM_FIRST_LOG_PAGEID_IN_BLOCK (blockid) `((blockid) \* vacuum\_Data.log\_block\_npages)`
define	VACUUM_LAST_LOG_PAGEID_IN_BLOCK (blockid) `([VACUUM\_FIRST\_LOG\_PAGEID\_IN\_BLOCK](vacuum_8c.md#define-vacuum_first_log_pageid_in_block) (blockid + 1) - 1)`
define	VACUUM_LOG_BLOCK_BUFFER_INVALID `(-1)`
define	VACUUM_LOG_DATA_ENTRY_AS_ARGS (data) `/* multi line expression */`
define	VACUUM_LOG_DATA_ENTRY_MSG (name) `"name = {blockid = %[lld](broker__monitor_8c.md#function-timeout), flags = %[lld](broker__monitor_8c.md#function-timeout), start\_lsa = %[lld](broker__monitor_8c.md#function-timeout)\\|%d, oldest\_visible\_mvccid=%[llu](broker__monitor_8c.md#function-timeout), newest\_mvccid=%[llu](broker__monitor_8c.md#function-timeout) }"`
define	VACUUM_LOG_VACUUM_HEAP_ALL_VACUUMED `0x4000`
define	VACUUM_LOG_VACUUM_HEAP_MASK `0xC000`
define	VACUUM_LOG_VACUUM_HEAP_REUSABLE `0x8000`
define	VACUUM_MAX_TASKS_IN_WORKER_POOL `(([size\_t](broker__monitor_8c.md#function-timeout)) (3 \* [prm\_get\_integer\_value](system__parameter_8h.md#function-prm_get_integer_value) (PRM\_ID\_VACUUM\_WORKER\_COUNT)))`
define	VACUUM_PERF_HEAP_START (thread_p, helper) `[PERF\_UTIME\_TRACKER\_START](perf__monitor_8h.md#define-perf_utime_tracker_start) (thread\_p, &([helper](broker__monitor_8c.md#function-timeout))->time\_track);`
define	VACUUM_PERF_HEAP_TRACK_EXECUTE (thread_p, helper) `/* multi line expression */`
define	VACUUM_PERF_HEAP_TRACK_LOGGING (thread_p, helper) `/* multi line expression */`
define	VACUUM_PERF_HEAP_TRACK_PREPARE (thread_p, helper) `/* multi line expression */`
define	VACUUM_PREFETCH_LOG_BLOCK_BUFFER_PAGES `(([size\_t](broker__monitor_8c.md#function-timeout)) (1 + vacuum\_Data.log\_block\_npages))`
define	VACUUM_STATS_CACHE_SIZE `100`
define	VACUUM_TRACK_DROPPED_FILES_SIZE `([DB\_PAGESIZE](storage__common_8h.md#define-db_pagesize) + [sizeof](broker__monitor_8c.md#function-timeout) ([VACUUM\_TRACK\_DROPPED\_FILES](vacuum_8c.md#typedef-vacuum_track_dropped_files) \*))`
define	VACUUM_VERIFY_VACUUM_DATA (thread_p) `[vacuum\_verify\_vacuum\_data\_debug](vacuum_8c.md#function-vacuum_verify_vacuum_data_debug) (thread\_p)`
define	VACUUM_WORKER_INDEX_TO_TRANID (index) `(-index + [LOG\_LAST\_VACUUM\_WORKER\_TRANID](broker__monitor_8c.md#function-timeout))`
define	VACUUM_WORKER_TRANID_TO_INDEX (trid) `(-trid + [LOG\_LAST\_VACUUM\_WORKER\_TRANID](broker__monitor_8c.md#function-timeout))`
define	__STDC_FORMAT_MACROS
define	vacuum_fix_data_page (thread_p, vpidp) `/* multi line expression */`
define	vacuum_fix_dropped_entries_page (thread_p, vpidp, latch) `/* multi line expression */`
define	vacuum_job_cursor_print_args (cursor) `([long](broker__monitor_8c.md#function-timeout) [long](broker__monitor_8c.md#function-timeout) [int](broker__monitor_8c.md#function-timeout)) (cursor).get\_blockid (), [VPID\_AS\_ARGS](dbtype__def_8h.md#define-vpid_as_args) (&(cursor).get\_page\_vpid ()), ([int](broker__monitor_8c.md#function-timeout)) (cursor).get\_index ()`
define	vacuum_job_cursor_print_format `"vacuum\_job\_cursor(%[lld](broker__monitor_8c.md#function-timeout), %d\\|%d\\|%d)"`
define	vacuum_set_dirty_dropped_entries_page (thread_p, dropped_page, free) `/* multi line expression */`
define	vacuum_unfix_data_page (thread_p, data_page) `/* multi line expression */`
define	vacuum_unfix_dropped_entries_page (thread_p, dropped_page) `/* multi line expression */`
define	vacuum_unfix_first_and_last_data_page (thread_p) `/* multi line expression */`

Public Types Documentation¶

typedef VACUUM_DATA¶

typedef struct vacuum_data VACUUM_DATA;

typedef VACUUM_DATA_ENTRY¶

typedef struct vacuum_data_entry VACUUM_DATA_ENTRY;

typedef VACUUM_DATA_LOAD¶

typedef struct vacuum_data_load VACUUM_DATA_LOAD;

typedef VACUUM_DATA_PAGE¶

typedef struct vacuum_data_page VACUUM_DATA_PAGE;

typedef VACUUM_DROPPED_FILE¶

typedef struct vacuum_dropped_file VACUUM_DROPPED_FILE;

typedef VACUUM_DROPPED_FILES_PAGE¶

typedef struct vacuum_dropped_files_page VACUUM_DROPPED_FILES_PAGE;

typedef VACUUM_DROPPED_FILES_RCV_DATA¶

typedef struct vacuum_dropped_files_rcv_data VACUUM_DROPPED_FILES_RCV_DATA;

typedef VACUUM_HEAP_HELPER¶

typedef struct vacuum_heap_helper VACUUM_HEAP_HELPER;

typedef VACUUM_TRACK_DROPPED_FILES¶

typedef struct vacuum_track_dropped_files VACUUM_TRACK_DROPPED_FILES;

Public Attributes Documentation¶

variable g_ovfp_threshold_mgr¶

class ovfp_threshold_mgr g_ovfp_threshold_mgr;

variable vacuum_Block_data_buffer¶

lockfree::circular_queue<vacuum_data_entry>* vacuum_Block_data_buffer;

variable vacuum_Data_load¶

VACUUM_DATA_LOAD vacuum_Data_load;

variable vacuum_Dropped_files_mutex¶

pthread_mutex_t vacuum_Dropped_files_mutex;

variable vacuum_Dropped_files_version¶

INT32 vacuum_Dropped_files_version;

variable vacuum_Finished_job_queue¶

lockfree::circular_queue<VACUUM_LOG_BLOCKID>* vacuum_Finished_job_queue;

variable vacuum_Is_booted¶

bool vacuum_Is_booted;

variable vacuum_Last_dropped_vfid¶

VFID vacuum_Last_dropped_vfid;

variable vacuum_Master¶

VACUUM_WORKER vacuum_Master;

variable vacuum_Track_dropped_files¶

VACUUM_TRACK_DROPPED_FILES* vacuum_Track_dropped_files;

variable vacuum_Workers¶

VACUUM_WORKER vacuum_Workers[50];

Public Static Attributes Documentation¶

variable vacuum_Data¶

VACUUM_DATA vacuum_Data;

variable vacuum_Dropped_files_count¶

INT32 vacuum_Dropped_files_count;

variable vacuum_Dropped_files_loaded¶

bool vacuum_Dropped_files_loaded;

variable vacuum_Dropped_files_vfid¶

VFID vacuum_Dropped_files_vfid;

variable vacuum_Dropped_files_vpid¶

VPID vacuum_Dropped_files_vpid;

variable vacuum_Master_daemon¶

cubthread::daemon* vacuum_Master_daemon;

variable vacuum_Master_entry_manager¶

vacuum_master_entry_manager* vacuum_Master_entry_manager;

variable vacuum_Worker_entry_manager¶

vacuum_worker_entry_manager* vacuum_Worker_entry_manager;

variable vacuum_Worker_threads¶

cubthread::stats_worker_pool_type* vacuum_Worker_threads;

Public Functions Documentation¶

function REGISTER_DAEMON¶

REGISTER_DAEMON (
    vacuum
)

function REGISTER_WORKERPOOL¶

REGISTER_WORKERPOOL (
    vacuum,
    () { return  prm_get_integer_value ( PRM_ID_VACUUM_WORKER_COUNT );}
)

function vacuum_boot¶

int vacuum_boot (
    THREAD_ENTRY * thread_p
)

function vacuum_check_not_vacuumed_rec_header¶

DISK_ISVALID vacuum_check_not_vacuumed_rec_header (
    THREAD_ENTRY * thread_p,
    OID * oid,
    OID * class_oid,
    MVCC_REC_HEADER * rec_header,
    int btree_node_type
)

function vacuum_check_not_vacuumed_recdes¶

DISK_ISVALID vacuum_check_not_vacuumed_recdes (
    THREAD_ENTRY * thread_p,
    OID * oid,
    OID * class_oid,
    RECDES * recdes,
    int btree_node_type
)

function vacuum_consume_buffer_log_blocks¶

int vacuum_consume_buffer_log_blocks (
    THREAD_ENTRY * thread_p
)

function vacuum_create_file_for_dropped_files¶

int vacuum_create_file_for_dropped_files (
    THREAD_ENTRY * thread_p,
    VFID * dropped_files_vfid
)

function vacuum_create_file_for_vacuum_data¶

int vacuum_create_file_for_vacuum_data (
    THREAD_ENTRY * thread_p,
    VFID * vacuum_data_vfid
)

function vacuum_data_load_and_recover¶

int vacuum_data_load_and_recover (
    THREAD_ENTRY * thread_p
)

function vacuum_finalize¶

void vacuum_finalize (
    THREAD_ENTRY * thread_p
)

function vacuum_get_log_blockid¶

VACUUM_LOG_BLOCKID vacuum_get_log_blockid (
    LOG_PAGEID pageid
)

function vacuum_heap_page¶

int vacuum_heap_page (
    THREAD_ENTRY * thread_p,
    VACUUM_HEAP_OBJECT * heap_objects,
    int n_heap_objects,
    MVCCID threshold_mvccid,
    HFID * hfid,
    bool * reusable,
    bool was_interrupted
)

function vacuum_init_thread_context¶

void vacuum_init_thread_context (
    cubthread::entry & context,
    thread_type type,
    VACUUM_WORKER * worker
)

function vacuum_initialize¶

int vacuum_initialize (
    THREAD_ENTRY * thread_p,
    int vacuum_log_block_npages,
    VFID * vacuum_data_vfid,
    VFID * dropped_files_vfid,
    bool is_restore
)

function vacuum_is_file_dropped¶

int vacuum_is_file_dropped (
    THREAD_ENTRY * thread_p,
    bool * is_file_dropped,
    VFID * vfid,
    MVCCID mvccid
)

function vacuum_is_mvccid_vacuumed¶

bool vacuum_is_mvccid_vacuumed (
    MVCCID id
)

function vacuum_is_safe_to_remove_archives¶

bool vacuum_is_safe_to_remove_archives (
    void
)

function vacuum_load_dropped_files_from_disk¶

int vacuum_load_dropped_files_from_disk (
    THREAD_ENTRY * thread_p
)

function vacuum_log_add_dropped_file¶

void vacuum_log_add_dropped_file (
    THREAD_ENTRY * thread_p,
    const  VFID * vfid,
    const  OID * class_oid,
    bool pospone_or_undo
)

function vacuum_min_log_pageid_to_keep¶

LOG_PAGEID vacuum_min_log_pageid_to_keep (
    THREAD_ENTRY * thread_p
)

function vacuum_notify_es_deleted¶

void vacuum_notify_es_deleted (
    THREAD_ENTRY * thread_p,
    const  char * uri
)

function vacuum_notify_server_crashed¶

void vacuum_notify_server_crashed (
    LOG_LSA * recovery_lsa
)

function vacuum_notify_server_shutdown¶

void vacuum_notify_server_shutdown (
    void
)

function vacuum_produce_log_block_data¶

void vacuum_produce_log_block_data (
    THREAD_ENTRY * thread_p
)

function vacuum_reset_data_after_copydb¶

int vacuum_reset_data_after_copydb (
    THREAD_ENTRY * thread_p
)

function vacuum_rv_check_at_undo¶

int vacuum_rv_check_at_undo (
    THREAD_ENTRY * thread_p,
    PAGE_PTR pgptr,
    INT16 slotid,
    INT16 rec_type
)

function vacuum_rv_es_nop¶

int vacuum_rv_es_nop (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_notify_dropped_file¶

int vacuum_rv_notify_dropped_file (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_add_dropped_file¶

int vacuum_rv_redo_add_dropped_file (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_append_data¶

int vacuum_rv_redo_append_data (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_append_data_dump¶

void vacuum_rv_redo_append_data_dump (
    FILE * fp,
    int length,
    void * data
)

function vacuum_rv_redo_cleanup_dropped_files¶

int vacuum_rv_redo_cleanup_dropped_files (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_data_finished¶

int vacuum_rv_redo_data_finished (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_data_finished_dump¶

void vacuum_rv_redo_data_finished_dump (
    FILE * fp,
    int length,
    void * data
)

function vacuum_rv_redo_initialize_data_page¶

int vacuum_rv_redo_initialize_data_page (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_remove_ovf_insid¶

int vacuum_rv_redo_remove_ovf_insid (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_start_job¶

int vacuum_rv_redo_start_job (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_vacuum_complete¶

int vacuum_rv_redo_vacuum_complete (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_vacuum_heap_page¶

int vacuum_rv_redo_vacuum_heap_page (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_redo_vacuum_heap_record¶

int vacuum_rv_redo_vacuum_heap_record (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_replace_dropped_file¶

int vacuum_rv_replace_dropped_file (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_set_next_page_dropped_files¶

int vacuum_rv_set_next_page_dropped_files (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_undo_add_dropped_file¶

int vacuum_rv_undo_add_dropped_file (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_undo_vacuum_heap_record¶

int vacuum_rv_undo_vacuum_heap_record (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_undoredo_data_set_link¶

int vacuum_rv_undoredo_data_set_link (
    THREAD_ENTRY * thread_p,
    LOG_RCV * rcv
)

function vacuum_rv_undoredo_data_set_link_dump¶

void vacuum_rv_undoredo_data_set_link_dump (
    FILE * fp,
    int length,
    void * data
)

function vacuum_sa_reflect_last_blockid¶

void vacuum_sa_reflect_last_blockid (
    THREAD_ENTRY * thread_p
)

function vacuum_stop_master¶

void vacuum_stop_master (
    THREAD_ENTRY * thread_p
)

function vacuum_stop_workers¶

void vacuum_stop_workers (
    THREAD_ENTRY * thread_p
)

function xvacuum¶

int xvacuum (
    THREAD_ENTRY * thread_p
)

function xvacuum_dump¶

void xvacuum_dump (
    THREAD_ENTRY * thread_p,
    FILE * outfp
)

Public Static Functions Documentation¶

function is_not_vacuumed_and_lost¶

static bool is_not_vacuumed_and_lost (
    THREAD_ENTRY * thread_p,
    MVCC_REC_HEADER * rec_header
)

function print_not_vacuumed_to_log¶

static void print_not_vacuumed_to_log (
    OID * oid,
    OID * class_oid,
    MVCC_REC_HEADER * rec_header,
    int btree_node_type
)

function vacuum_add_dropped_file¶

static int vacuum_add_dropped_file (
    THREAD_ENTRY * thread_p,
    VFID * vfid,
    MVCCID mvccid
)

function vacuum_check_shutdown_interruption¶

static void vacuum_check_shutdown_interruption (
    const  THREAD_ENTRY * thread_p,
    int error_code
)

function vacuum_cleanup_collected_by_vfid¶

static void vacuum_cleanup_collected_by_vfid (
    VACUUM_WORKER * worker,
    VFID * vfid
)

function vacuum_cleanup_dropped_files¶

static int vacuum_cleanup_dropped_files (
    THREAD_ENTRY * thread_p
)

function vacuum_collect_heap_objects¶

static int vacuum_collect_heap_objects (
    THREAD_ENTRY * thread_p,
    VACUUM_WORKER * worker,
    OID * oid,
    VFID * vfid
)

function vacuum_compare_blockids¶

static int vacuum_compare_blockids (
    const  void * ptr1,
    const  void * ptr2
)

function vacuum_compare_dropped_files¶

static int vacuum_compare_dropped_files (
    const  void * a,
    const  void * b
)

function vacuum_compare_dropped_files_version¶

static int vacuum_compare_dropped_files_version (
    INT32 version_a,
    INT32 version_b
)

function vacuum_compare_heap_object¶

static int vacuum_compare_heap_object (
    const  void * a,
    const  void * b
)

function vacuum_convert_thread_to_master¶

static void vacuum_convert_thread_to_master (
    THREAD_ENTRY * thread_p,
    thread_type & save_type
)

function vacuum_convert_thread_to_worker¶

static void vacuum_convert_thread_to_worker (
    THREAD_ENTRY * thread_p,
    VACUUM_WORKER * worker,
    thread_type & save_type
)

function vacuum_copy_data_from_log¶

static void vacuum_copy_data_from_log (
    THREAD_ENTRY * thread_p,
    char * area,
    int length,
    LOG_LSA * log_lsa,
    LOG_PAGE * log_page
)

function vacuum_data_empty_page¶

static void vacuum_data_empty_page (
    THREAD_ENTRY * thread_p,
    VACUUM_DATA_PAGE * prev_data_page,
    VACUUM_DATA_PAGE ** data_page
)

function vacuum_data_empty_update_last_blockid¶

static void vacuum_data_empty_update_last_blockid (
    THREAD_ENTRY * thread_p
)

function vacuum_data_initialize_new_page¶

static void vacuum_data_initialize_new_page (
    THREAD_ENTRY * thread_p,
    VACUUM_DATA_PAGE * data_page
)

function vacuum_data_load_first_and_last_page¶

static void vacuum_data_load_first_and_last_page (
    THREAD_ENTRY * thread_p
)

function vacuum_data_mark_finished¶

static int vacuum_data_mark_finished (
    THREAD_ENTRY * thread_p
)

function vacuum_data_unload_first_and_last_page¶

static void vacuum_data_unload_first_and_last_page (
    THREAD_ENTRY * thread_p
)

function vacuum_dropped_files_set_next_page¶

static void vacuum_dropped_files_set_next_page (
    THREAD_ENTRY * thread_p,
    VACUUM_DROPPED_FILES_PAGE * page_p,
    VPID * next_page
)

function vacuum_fetch_log_page¶

static int vacuum_fetch_log_page (
    THREAD_ENTRY * thread_p,
    LOG_PAGEID log_pageid,
    LOG_PAGE * log_page
)

function vacuum_finalize_worker¶

static void vacuum_finalize_worker (
    THREAD_ENTRY * thread_p,
    VACUUM_WORKER * worker_info
)

function vacuum_find_dropped_file¶

static int vacuum_find_dropped_file (
    THREAD_ENTRY * thread_p,
    bool * is_file_dropped,
    VFID * vfid,
    MVCCID mvccid
)

function vacuum_finished_block_vacuum¶

static void vacuum_finished_block_vacuum (
    THREAD_ENTRY * thread_p,
    VACUUM_DATA_ENTRY * block_data,
    bool is_vacuum_complete
)

function vacuum_get_first_page_dropped_files¶

static int vacuum_get_first_page_dropped_files (
    THREAD_ENTRY * thread_p,
    VPID * first_page_vpid
)

function vacuum_get_worker_min_dropped_files_version¶

static INT32 vacuum_get_worker_min_dropped_files_version (
    void
)

function vacuum_heap¶

static int vacuum_heap (
    THREAD_ENTRY * thread_p,
    VACUUM_WORKER * worker,
    MVCCID threshold_mvccid,
    bool was_interrupted
)

function vacuum_heap_get_hfid_and_file_type¶

static int vacuum_heap_get_hfid_and_file_type (
    THREAD_ENTRY * thread_p,
    VACUUM_HEAP_HELPER * helper,
    const  VFID * vfid
)

function vacuum_heap_page_log_and_reset¶

static void vacuum_heap_page_log_and_reset (
    THREAD_ENTRY * thread_p,
    VACUUM_HEAP_HELPER * helper,
    bool update_best_space_stat,
    bool unlatch_page
)

function vacuum_heap_prepare_record¶

static int vacuum_heap_prepare_record (
    THREAD_ENTRY * thread_p,
    VACUUM_HEAP_HELPER * helper
)

function vacuum_heap_record¶

static int vacuum_heap_record (
    THREAD_ENTRY * thread_p,
    VACUUM_HEAP_HELPER * helper
)

function vacuum_heap_record_insid_and_prev_version¶

static int vacuum_heap_record_insid_and_prev_version (
    THREAD_ENTRY * thread_p,
    VACUUM_HEAP_HELPER * helper
)

function vacuum_init_data_page_with_last_blockid¶

static void vacuum_init_data_page_with_last_blockid (
    THREAD_ENTRY * thread_p,
    VACUUM_DATA_PAGE * data_page,
    VACUUM_LOG_BLOCKID blockid
)

function vacuum_is_empty¶

static bool vacuum_is_empty (
    void
)

function vacuum_is_work_in_progress¶

static bool vacuum_is_work_in_progress (
    THREAD_ENTRY * thread_p
)

function vacuum_log_cleanup_dropped_files¶

static void vacuum_log_cleanup_dropped_files (
    THREAD_ENTRY * thread_p,
    PAGE_PTR page_p,
    INT16 * indexes,
    INT16 n_indexes
)

function vacuum_log_prefetch_vacuum_block¶

static int vacuum_log_prefetch_vacuum_block (
    THREAD_ENTRY * thread_p,
    VACUUM_DATA_ENTRY * entry
)

function vacuum_log_redoundo_vacuum_record¶

static void vacuum_log_redoundo_vacuum_record (
    THREAD_ENTRY * thread_p,
    PAGE_PTR page_p,
    PGSLOTID slotid,
    RECDES * undo_recdes,
    bool reusable
)

function vacuum_log_remove_ovf_insid¶

static void vacuum_log_remove_ovf_insid (
    THREAD_ENTRY * thread_p,
    PAGE_PTR ovfpage
)

function vacuum_log_vacuum_heap_page¶

static void vacuum_log_vacuum_heap_page (
    THREAD_ENTRY * thread_p,
    PAGE_PTR page_p,
    int n_slots,
    PGSLOTID * slots,
    MVCC_SATISFIES_VACUUM_RESULT * results,
    bool reusable,
    bool all_vacuumed
)

function vacuum_notify_all_workers_dropped_file¶

static void vacuum_notify_all_workers_dropped_file (
    const  VFID & vfid_dropped,
    MVCCID mvccid
)

function vacuum_process_log_block¶

static int vacuum_process_log_block (
    THREAD_ENTRY * thread_p,
    VACUUM_DATA_ENTRY * block_data,
    bool sa_mode_partial_block
)

function vacuum_process_log_record¶

static int vacuum_process_log_record (
    THREAD_ENTRY * thread_p,
    VACUUM_WORKER * worker,
    LOG_LSA * log_lsa_p,
    LOG_PAGE * log_page_p,
    LOG_DATA * log_record_data,
    MVCCID * mvccid,
    char ** undo_data_ptr,
    int * undo_data_size,
    LOG_VACUUM_INFO * vacuum_info,
    bool * is_file_dropped,
    bool stop_after_vacuum_info
)

function vacuum_read_advance_when_doesnt_fit¶

static void vacuum_read_advance_when_doesnt_fit (
    THREAD_ENTRY * thread_entry,
    size_t size,
    LOG_LSA * log_lsa,
    LOG_PAGE * log_page
)

function vacuum_read_log_add_aligned¶

static void vacuum_read_log_add_aligned (
    THREAD_ENTRY * thread_entry,
    size_t size,
    LOG_LSA * log_lsa,
    LOG_PAGE * log_page
)

function vacuum_read_log_aligned¶

static void vacuum_read_log_aligned (
    THREAD_ENTRY * thread_entry,
    LOG_LSA * log_lsa,
    LOG_PAGE * log_page
)

function vacuum_recover_lost_block_data¶

static int vacuum_recover_lost_block_data (
    THREAD_ENTRY * thread_p
)

function vacuum_restore_thread¶

static void vacuum_restore_thread (
    THREAD_ENTRY * thread_p,
    thread_type save_type
)

function vacuum_sa_run_job¶

static void vacuum_sa_run_job (
    THREAD_ENTRY * thread_p,
    const  VACUUM_DATA_ENTRY & data_entry,
    bool is_partial,
    PERF_UTIME_TRACKER & perf_tracker
)

function vacuum_set_dirty_data_page¶

static inline void vacuum_set_dirty_data_page (
    cubthread::entry * thread_p,
    vacuum_data_page * data_page,
    bool free
)

function vacuum_set_dirty_data_page_dont_free¶

static inline void vacuum_set_dirty_data_page_dont_free (
    cubthread::entry * thread_p,
    vacuum_data_page * data_page
)

function vacuum_update_keep_from_log_pageid¶

static void vacuum_update_keep_from_log_pageid (
    THREAD_ENTRY * thread_p
)

function vacuum_verify_vacuum_data_debug¶

static void vacuum_verify_vacuum_data_debug (
    THREAD_ENTRY * thread_p
)

function vacuum_verify_vacuum_data_page_fix_count¶

static void vacuum_verify_vacuum_data_page_fix_count (
    THREAD_ENTRY * thread_p
)

function vacuum_worker_allocate_resources¶

static int vacuum_worker_allocate_resources (
    THREAD_ENTRY * thread_p,
    VACUUM_WORKER * worker
)

Macro Definition Documentation¶

define ES_NOTIFY_VACUUM_FOR_DELETE_BUFFER_SIZE¶

#define ES_NOTIFY_VACUUM_FOR_DELETE_BUFFER_SIZE `( INT_ALIGNMENT +  /* Aligning buffer start */       \ OR_INT_SIZE +   /* String length */           \ ES_MAX_URI_LEN +    /* URI string */              \ INT_ALIGNMENT )     /* Alignment of packed string */`

define MAX_PAGE_MAX_DATA_ENTRIES¶

#define MAX_PAGE_MAX_DATA_ENTRIES `( IO_MAX_PAGE_SIZE / sizeof ( VACUUM_DATA_ENTRY ))`

define MAX_SLOTS_IN_PAGE¶

#define MAX_SLOTS_IN_PAGE `( IO_MAX_PAGE_SIZE / sizeof ( SPAGE_SLOT ))`

define TEMP_BUFFER_SIZE¶

#define TEMP_BUFFER_SIZE `VACUUM_FINISHED_JOB_QUEUE_CAPACITY`

define TEMP_BUFFER_SIZE¶

#define TEMP_BUFFER_SIZE `VACUUM_FINISHED_JOB_QUEUE_CAPACITY`

define VACUUM_BLOCKID_GET_FLAGS¶

#define VACUUM_BLOCKID_GET_FLAGS (
    blockid
) `((blockid) & VACUUM_DATA_ENTRY_FLAG_MASK )`

define VACUUM_BLOCKID_WITHOUT_FLAGS¶

#define VACUUM_BLOCKID_WITHOUT_FLAGS (
    blockid
) `((blockid) & VACUUM_DATA_ENTRY_BLOCKID_MASK )`

define VACUUM_BLOCK_CLEAR_INTERRUPTED¶

#define VACUUM_BLOCK_CLEAR_INTERRUPTED (
    blockid
) `((blockid) &= ~ VACUUM_BLOCK_FLAG_INTERRUPTED )`

define VACUUM_BLOCK_DATA_BUFFER_CAPACITY¶

#define VACUUM_BLOCK_DATA_BUFFER_CAPACITY `1024`

define VACUUM_BLOCK_FLAG_INTERRUPTED¶

#define VACUUM_BLOCK_FLAG_INTERRUPTED `0x2000000000000000`

define VACUUM_BLOCK_IS_INTERRUPTED¶

#define VACUUM_BLOCK_IS_INTERRUPTED (
    blockid
) `(((blockid) & VACUUM_BLOCK_FLAG_INTERRUPTED ) != 0)`

define VACUUM_BLOCK_SET_INTERRUPTED¶

#define VACUUM_BLOCK_SET_INTERRUPTED (
    blockid
) `((blockid) |= VACUUM_BLOCK_FLAG_INTERRUPTED )`

define VACUUM_BLOCK_STATUS¶

#define VACUUM_BLOCK_STATUS (
    blockid
) `((blockid) & VACUUM_BLOCK_STATUS_MASK )`

define VACUUM_BLOCK_STATUS_AVAILABLE¶

#define VACUUM_BLOCK_STATUS_AVAILABLE `0x0000000000000000`

define VACUUM_BLOCK_STATUS_IN_PROGRESS_VACUUM¶

#define VACUUM_BLOCK_STATUS_IN_PROGRESS_VACUUM `0x4000000000000000`

define VACUUM_BLOCK_STATUS_IS_AVAILABLE¶

#define VACUUM_BLOCK_STATUS_IS_AVAILABLE (
    blockid
) `( VACUUM_BLOCK_STATUS (blockid) == VACUUM_BLOCK_STATUS_AVAILABLE )`

define VACUUM_BLOCK_STATUS_IS_IN_PROGRESS¶

#define VACUUM_BLOCK_STATUS_IS_IN_PROGRESS (
    blockid
) `( VACUUM_BLOCK_STATUS (blockid) == VACUUM_BLOCK_STATUS_IN_PROGRESS_VACUUM )`

define VACUUM_BLOCK_STATUS_IS_VACUUMED¶

#define VACUUM_BLOCK_STATUS_IS_VACUUMED (
    blockid
) `( VACUUM_BLOCK_STATUS (blockid) == VACUUM_BLOCK_STATUS_VACUUMED )`

define VACUUM_BLOCK_STATUS_MASK¶

#define VACUUM_BLOCK_STATUS_MASK `0xC000000000000000`

define VACUUM_BLOCK_STATUS_SET_AVAILABLE¶

#define VACUUM_BLOCK_STATUS_SET_AVAILABLE (
    blockid
) `((blockid) = ((blockid) & ~ VACUUM_BLOCK_STATUS_MASK ) | VACUUM_BLOCK_STATUS_AVAILABLE )`

define VACUUM_BLOCK_STATUS_SET_IN_PROGRESS¶

#define VACUUM_BLOCK_STATUS_SET_IN_PROGRESS (
    blockid
) `((blockid) = ((blockid) & ~ VACUUM_BLOCK_STATUS_MASK ) | VACUUM_BLOCK_STATUS_IN_PROGRESS_VACUUM )`

define VACUUM_BLOCK_STATUS_SET_VACUUMED¶

#define VACUUM_BLOCK_STATUS_SET_VACUUMED (
    blockid
) `((blockid) = ((blockid) & ~ VACUUM_BLOCK_STATUS_MASK ) | VACUUM_BLOCK_STATUS_VACUUMED )`

define VACUUM_BLOCK_STATUS_VACUUMED¶

#define VACUUM_BLOCK_STATUS_VACUUMED `0x8000000000000000`

define VACUUM_CLEANUP_DROPPED_FILES_MAX_REDO_CRUMBS¶

#define VACUUM_CLEANUP_DROPPED_FILES_MAX_REDO_CRUMBS `3`

define VACUUM_DATA_ENTRY_BLOCKID_MASK¶

#define VACUUM_DATA_ENTRY_BLOCKID_MASK `0x1FFFFFFFFFFFFFFF`

define VACUUM_DATA_ENTRY_FLAG_MASK¶

#define VACUUM_DATA_ENTRY_FLAG_MASK `0xE000000000000000`

define VACUUM_DATA_PAGE_HEADER_SIZE¶

#define VACUUM_DATA_PAGE_HEADER_SIZE `( offsetof ( VACUUM_DATA_PAGE , data))`

define VACUUM_DEFAULT_HEAP_OBJECT_BUFFER_SIZE¶

#define VACUUM_DEFAULT_HEAP_OBJECT_BUFFER_SIZE `4000`

define VACUUM_DROPPED_FILES_MAX_PAGE_CAPACITY¶

#define VACUUM_DROPPED_FILES_MAX_PAGE_CAPACITY `/* multi line expression */`

define VACUUM_DROPPED_FILES_PAGE_CAPACITY¶

#define VACUUM_DROPPED_FILES_PAGE_CAPACITY `/* multi line expression */`

define VACUUM_DROPPED_FILES_PAGE_HEADER_SIZE¶

#define VACUUM_DROPPED_FILES_PAGE_HEADER_SIZE `( offsetof ( VACUUM_DROPPED_FILES_PAGE , dropped_files))`

define VACUUM_DROPPED_FILE_FLAG_DUPLICATE¶

#define VACUUM_DROPPED_FILE_FLAG_DUPLICATE `0x8000`

define VACUUM_FINISHED_JOB_QUEUE_CAPACITY¶

#define VACUUM_FINISHED_JOB_QUEUE_CAPACITY `2048`

define VACUUM_FIRST_LOG_PAGEID_IN_BLOCK¶

#define VACUUM_FIRST_LOG_PAGEID_IN_BLOCK (
    blockid
) `((blockid) * vacuum_Data.log_block_npages)`

define VACUUM_LAST_LOG_PAGEID_IN_BLOCK¶

#define VACUUM_LAST_LOG_PAGEID_IN_BLOCK (
    blockid
) `( VACUUM_FIRST_LOG_PAGEID_IN_BLOCK (blockid + 1) - 1)`

define VACUUM_LOG_BLOCK_BUFFER_INVALID¶

#define VACUUM_LOG_BLOCK_BUFFER_INVALID `(-1)`

define VACUUM_LOG_DATA_ENTRY_AS_ARGS¶

#define VACUUM_LOG_DATA_ENTRY_AS_ARGS (
    data
) `/* multi line expression */`

define VACUUM_LOG_DATA_ENTRY_MSG¶

#define VACUUM_LOG_DATA_ENTRY_MSG (
    name
) `"name = {blockid = % lld , flags = % lld , start_lsa = % lld |%d, oldest_visible_mvccid=% llu , newest_mvccid=% llu }"`

define VACUUM_LOG_VACUUM_HEAP_ALL_VACUUMED¶

#define VACUUM_LOG_VACUUM_HEAP_ALL_VACUUMED `0x4000`

define VACUUM_LOG_VACUUM_HEAP_MASK¶

#define VACUUM_LOG_VACUUM_HEAP_MASK `0xC000`

define VACUUM_LOG_VACUUM_HEAP_REUSABLE¶

#define VACUUM_LOG_VACUUM_HEAP_REUSABLE `0x8000`

define VACUUM_MAX_TASKS_IN_WORKER_POOL¶

#define VACUUM_MAX_TASKS_IN_WORKER_POOL `(( size_t ) (3 * prm_get_integer_value ( PRM_ID_VACUUM_WORKER_COUNT )))`

define VACUUM_PERF_HEAP_START¶

#define VACUUM_PERF_HEAP_START (
    thread_p,
    helper
) `PERF_UTIME_TRACKER_START (thread_p, &( helper )->time_track);`

define VACUUM_PERF_HEAP_TRACK_EXECUTE¶

#define VACUUM_PERF_HEAP_TRACK_EXECUTE (
    thread_p,
    helper
) `PERF_UTIME_TRACKER_TIME_AND_RESTART (thread_p, &( helper )->time_track, \ PSTAT_HEAP_VACUUM_EXECUTE )`

define VACUUM_PERF_HEAP_TRACK_LOGGING¶

#define VACUUM_PERF_HEAP_TRACK_LOGGING (
    thread_p,
    helper
) `PERF_UTIME_TRACKER_TIME_AND_RESTART (thread_p, &( helper )->time_track, \ PSTAT_HEAP_VACUUM_LOG )`

define VACUUM_PERF_HEAP_TRACK_PREPARE¶

#define VACUUM_PERF_HEAP_TRACK_PREPARE (
    thread_p,
    helper
) `PERF_UTIME_TRACKER_TIME_AND_RESTART (thread_p, &( helper )->time_track, \ PSTAT_HEAP_VACUUM_PREPARE )`

define VACUUM_PREFETCH_LOG_BLOCK_BUFFER_PAGES¶

#define VACUUM_PREFETCH_LOG_BLOCK_BUFFER_PAGES `(( size_t ) (1 + vacuum_Data.log_block_npages))`

define VACUUM_STATS_CACHE_SIZE¶

#define VACUUM_STATS_CACHE_SIZE `100`

define VACUUM_TRACK_DROPPED_FILES_SIZE¶

#define VACUUM_TRACK_DROPPED_FILES_SIZE `( DB_PAGESIZE + sizeof ( VACUUM_TRACK_DROPPED_FILES *))`

define VACUUM_VERIFY_VACUUM_DATA¶

#define VACUUM_VERIFY_VACUUM_DATA (
    thread_p
) `vacuum_verify_vacuum_data_debug (thread_p)`

define VACUUM_WORKER_INDEX_TO_TRANID¶

#define VACUUM_WORKER_INDEX_TO_TRANID (
    index
) `(-index + LOG_LAST_VACUUM_WORKER_TRANID )`

define VACUUM_WORKER_TRANID_TO_INDEX¶

#define VACUUM_WORKER_TRANID_TO_INDEX (
    trid
) `(-trid + LOG_LAST_VACUUM_WORKER_TRANID )`

define __STDC_FORMAT_MACROS¶

#define __STDC_FORMAT_MACROS

define vacuum_fix_data_page¶

#define vacuum_fix_data_page (
    thread_p,
    vpidp
) `/* multi line expression */`

define vacuum_fix_dropped_entries_page¶

#define vacuum_fix_dropped_entries_page (
    thread_p,
    vpidp,
    latch
) `(( VACUUM_DROPPED_FILES_PAGE *) pgbuf_fix (thread_p, vpidp , OLD_PAGE , \ latch , \ PGBUF_UNCONDITIONAL_LATCH ))`

define vacuum_job_cursor_print_args¶

#define vacuum_job_cursor_print_args (
    cursor
) `( long  long  int ) (cursor).get_blockid (), VPID_AS_ARGS (&(cursor).get_page_vpid ()), ( int ) (cursor).get_index ()`

define vacuum_job_cursor_print_format¶

#define vacuum_job_cursor_print_format `"vacuum_job_cursor(% lld , %d|%d|%d)"`

define vacuum_set_dirty_dropped_entries_page¶

#define vacuum_set_dirty_dropped_entries_page (
    thread_p,
    dropped_page,
    free
) `/* multi line expression */`

define vacuum_unfix_data_page¶

#define vacuum_unfix_data_page (
    thread_p,
    data_page
) `/* multi line expression */`

define vacuum_unfix_dropped_entries_page¶

#define vacuum_unfix_dropped_entries_page (
    thread_p,
    dropped_page
) `/* multi line expression */`

define vacuum_unfix_first_and_last_data_page¶

#define vacuum_unfix_first_and_last_data_page (
    thread_p
) `/* multi line expression */`

The documentation for this class was generated from the following file cubrid/src/query/vacuum.c