158 lines
5.4 KiB
C
158 lines
5.4 KiB
C
#ifndef _STASIS_FLAGS_H__
|
|
#define _STASIS_FLAGS_H__
|
|
#include <stasis/bufferManager.h>
|
|
#include <stasis/logger/logger2.h>
|
|
#include <stasis/dirtyPageTable.h>
|
|
/**
|
|
This is the type of buffer manager that is being used.
|
|
|
|
Before Stasis is intialized it will be set to a default value.
|
|
It may be changed before Tinit() is called, or overridden at
|
|
compile time by defining USE_BUFFER_MANAGER.
|
|
|
|
(eg: gcc ... -DUSE_BUFFER_MANAGER=BUFFER_MANAGER_FOO)
|
|
|
|
@see constants.h for a list of recognized buffer manager implementations.
|
|
(The constants are named BUFFER_MANAGER_*)
|
|
|
|
*/
|
|
extern stasis_buffer_manager_t* (*stasis_buffer_manager_factory)(stasis_log_t*, stasis_dirty_page_table_t*);
|
|
|
|
extern pageid_t stasis_buffer_manager_size;
|
|
/**
|
|
If this is true, then the only thread that will perform writeback is the
|
|
buffer manager writeback thread. It turns out that splitting sequential
|
|
writes across many threads leads to a 90-95% reduction in write throughput.
|
|
|
|
Otherwise (the default) application threads will help write back dirty pages
|
|
so that we can get good concurrency on our writes.
|
|
*/
|
|
extern int stasis_buffer_manager_hint_writes_are_sequential;
|
|
/**
|
|
If this is true, then disable some optimizations associated with sequential
|
|
write mode. This will needlessly burn CPU by inserting dirty pages into
|
|
the LRU. In sequential write mode, these dirty pages will cause populateTLS
|
|
to loop excessively, excercising all sorts of extremely rare thread
|
|
synchronization schedules.
|
|
*/
|
|
extern int stasis_buffer_manager_debug_stress_latching;
|
|
/**
|
|
This determines which type of file handle the buffer manager will use.
|
|
|
|
It defaults to BUFFER_MANAGER_FILE_HANDLE_NON_BLOCKING for a
|
|
non-blocking handle. It can be overridden at compile time by defining
|
|
BUFFER_MANAGER_FILE_HANDLE_TYPE.
|
|
|
|
@see constants.h for potential values. (The constants are named
|
|
BUFFER_MANAGER_FILE_HANDLE_*)
|
|
*/
|
|
extern int bufferManagerFileHandleType;
|
|
/**
|
|
Determines which type of slow handle non_blocking will use for the
|
|
buffer manager. Override at compile time by defining
|
|
BUFFER_MANAGER_NON_BLOCKING_SLOW_TYPE.
|
|
|
|
@see constants.h: Constants named IO_HANDLE_* are potential values.
|
|
*/
|
|
extern int bufferManagerNonBlockingSlowHandleType;
|
|
/**
|
|
If true, the buffer manager will use O_DIRECT. Set at compile time by
|
|
defining BUFFER_MANAGER_O_DIRECT.
|
|
*/
|
|
extern int bufferManagerO_DIRECT;
|
|
/**
|
|
If true, then concurrent LRU will use exponential backoff when it
|
|
has trouble finding a page to evict. If false, it will perform a
|
|
busy wait.
|
|
|
|
This definitely should be set to true when
|
|
stasis_buffer_manager_hint_sequential_writes is true. Otherwise
|
|
the only way that page writeback will be able to apply backpressure
|
|
to application threads will be to cause busy waits in concurrent
|
|
LRU.
|
|
*/
|
|
extern int stasis_replacement_policy_concurrent_wrapper_exponential_backoff;
|
|
/**
|
|
If true, then concurrent LRU will round the number of buckets up to
|
|
the next power of two, and use bit masks instead of mod when
|
|
assigning pages to buckets.
|
|
*/
|
|
extern int stasis_replacement_policy_concurrent_wrapper_power_of_two_buckets;
|
|
/**
|
|
If true, Stasis will suppress warnings regarding unclean shutdowns.
|
|
This is use to prevent spurious warnings during unit testing, and
|
|
must be set after Tinit() is called. (Tinit() resets this value to
|
|
false).
|
|
|
|
(This should not be set by applications, or during compilation.)
|
|
*/
|
|
extern int stasis_suppress_unclean_shutdown_warnings;
|
|
|
|
/*
|
|
Truncation options
|
|
*/
|
|
/**
|
|
If true, Stasis will spawn a background thread that periodically
|
|
truncates the log.
|
|
*/
|
|
extern int stasis_truncation_automatic;
|
|
|
|
/**
|
|
This is the log implementation that is being used.
|
|
|
|
Before Stasis is initialized it will be set to a default value.
|
|
It may be changed before Tinit() is called by assigning to it.
|
|
The default can be overridden at compile time by defining
|
|
USE_LOGGER.
|
|
|
|
(eg: gcc ... -DSTASIS_LOG_TYPE=LOG_TO_FOO)
|
|
|
|
@see constants.h for a list of recognized log implementations.
|
|
(The constants are named LOG_TO_*)
|
|
@todo rename LOG_TO_* constants to STASIS_LOG_TYPE_*
|
|
|
|
*/
|
|
extern int stasis_log_type;
|
|
|
|
extern size_t stasis_log_in_memory_max_entries;
|
|
|
|
extern char * stasis_log_file_name;
|
|
extern int stasis_log_file_mode;
|
|
extern int stasis_log_file_permissions;
|
|
extern int stasis_log_softcommit;
|
|
|
|
extern char * stasis_store_file_name;
|
|
|
|
/**
|
|
* Number of prefetch threads to create at startup. Zero disables the threads,
|
|
* which currently causes the pages to be read synchronously.
|
|
*/
|
|
extern int stasis_buffer_manager_hash_prefetch_count;
|
|
|
|
extern const char * stasis_log_dir_name;
|
|
/**
|
|
Maximum number of log chunks that will be created by file pool.
|
|
This number is treated as a hint.
|
|
*/
|
|
extern int stasis_log_file_pool_chunk_count_target;
|
|
/**
|
|
Minimum size of each completed log chunk. This number is treated
|
|
as a hint.
|
|
*/
|
|
extern lsn_t stasis_log_file_pool_chunk_min_size;
|
|
/**
|
|
Number of characters in log file names devoted to storing the LSN.
|
|
*/
|
|
extern const int stasis_log_dir_name_lsn_chars;
|
|
/**
|
|
Number of bytes that stasis' log may buffer before writeback.
|
|
*/
|
|
extern lsn_t stasis_log_file_write_buffer_size;
|
|
/**
|
|
Set to 1 if segment based recovery is enabled. This disables some
|
|
optimizations that assume all operations are page based.
|
|
|
|
@todo Stasis' segment implementation is a work in progress; therefore this is set to zero by default.
|
|
*/
|
|
extern int stasis_segments_enabled;
|
|
#endif
|