greg/stasis-aries-wal
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactored/created stasis_buffer_manager_open and stasis_handle_open

Browse source
This commit is contained in:
Sears Russell 2009-05-07 08:52:06 +00:00
parent b5b414490a
commit 7b4cf40221
18 changed files with 272 additions and 248 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/stasis/CMakeLists.txt
View file

@ -29,7 +29,7 @@ ADD_LIBRARY(stasis crc32.c redblack.c lhtable.c rw.c doubleLinkedList.c
operations/pageOrientedListNTA.c
operations/regions.c operations/lsmTree.c
io/rangeTracker.c io/memory.c io/file.c io/pfile.c
io/non_blocking.c io/debug.c
io/non_blocking.c io/debug.c io/handle.c
bufferManager/pageArray.c
bufferManager/bufferHash.c replacementPolicy/lru.c
replacementPolicy/lruFast.c)

2
src/stasis/Makefile.am
View file

@ -22,7 +22,7 @@ libstasis_la_SOURCES=crc32.c redblack.c lhtable.c rw.c doubleLinkedList.c common
operations/regions.c operations/lsmTree.c \
operations/lsnFreeSet.c \
io/rangeTracker.c io/memory.c io/file.c io/pfile.c io/non_blocking.c \
io/debug.c \
io/debug.c io/handle.c \
bufferManager.c \
bufferManager/pageArray.c \
bufferManager/bufferHash.c \

12
src/stasis/bufferManager.c
View file

@ -169,8 +169,8 @@ void (*releasePageImpl)(Page * p) = 0;
void (*writeBackPage)(Page * p) = 0;
void (*forcePages)() = 0;
void (*forcePageRange)(pageid_t start, pageid_t stop) = 0;
void (*bufDeinit)() = 0;
void (*simulateBufferManagerCrash)() = 0;
void (*stasis_buffer_manager_close)() = 0;
void (*stasis_buffer_manager_simulate_crash)() = 0;
Page * loadPage(int xid, pageid_t pageid) {
try_ret(NULL) {
@ -195,7 +195,7 @@ void releasePage(Page * p) {
releasePageImpl(p);
}
int bufInit(int type) {
int stasis_buffer_manager_open(int type) {
bufferManagerType = type;
static int lastType = 0;
if(type == BUFFER_MANAGER_REOPEN) {
@ -203,13 +203,13 @@ int bufInit(int type) {
}
lastType = type;
if(type == BUFFER_MANAGER_DEPRECATED_HASH) {
bufManBufInit();
stasis_buffer_manager_deprecated_open();
return 0;
} else if (type == BUFFER_MANAGER_MEM_ARRAY) {
paBufInit();
stasis_buffer_manager_mem_array_open();
return 0;
} else if (type == BUFFER_MANAGER_HASH) {
bhBufInit();
stasis_buffer_manager_hash_open();
return 0;
} else {
// XXX error handling

6
src/stasis/bufferManager/bufferHash.c
View file

@ -376,7 +376,7 @@ static void bhSimulateBufferManagerCrash() {
stasis_buffer_pool_deinit(stasis_buffer_pool);
}
void bhBufInit() {
void stasis_buffer_manager_hash_open() {
assert(!running);
@ -390,8 +390,8 @@ void bhBufInit() {
writeBackPage = bhWriteBackPage;
forcePages = bhForcePages;
forcePageRange = bhForcePageRange;
bufDeinit = bhBufDeinit;
simulateBufferManagerCrash = bhSimulateBufferManagerCrash;
stasis_buffer_manager_close = bhBufDeinit;
stasis_buffer_manager_simulate_crash = bhSimulateBufferManagerCrash;
stasis_buffer_pool = stasis_buffer_pool_init();

6
src/stasis/bufferManager/legacy/legacyBufferManager.c
View file

@ -27,7 +27,7 @@ static void bufManSimulateBufferManagerCrash();
static stasis_buffer_pool_t * stasis_buffer_pool;
int bufManBufInit() {
int stasis_buffer_manager_deprecated_open() {
releasePageImpl = bufManReleasePage;
loadPageImpl = bufManLoadPage;
@ -35,8 +35,8 @@ int bufManBufInit() {
writeBackPage = pageWrite;
forcePages = forcePageFile;
forcePageRange = forceRangePageFile;
bufDeinit = bufManBufDeinit;
simulateBufferManagerCrash = bufManSimulateBufferManagerCrash;
stasis_buffer_manager_close = bufManBufDeinit;
stasis_buffer_manager_simulate_crash = bufManSimulateBufferManagerCrash;
stasis_buffer_pool = stasis_buffer_pool_init();

6
src/stasis/bufferManager/pageArray.c
View file

@ -57,14 +57,14 @@ static void paBufDeinit() {
}
}
void paBufInit () {
void stasis_buffer_manager_mem_array_open () {
releasePageImpl = paReleasePage;
loadPageImpl = paLoadPage;
writeBackPage = paWriteBackPage;
forcePages = paForcePages;
bufDeinit = paBufDeinit;
simulateBufferManagerCrash = paBufDeinit;
stasis_buffer_manager_close = paBufDeinit;
stasis_buffer_manager_simulate_crash = paBufDeinit;
pageCount = 0;
pageMap = 0;

2
src/stasis/io/file.c
View file

@ -573,7 +573,7 @@ struct stasis_handle_t file_func = {
.error = 0
};
stasis_handle_t * stasis_handle(open_file)(lsn_t start_offset, char * filename, int flags, int mode) {
stasis_handle_t * stasis_handle(open_file)(lsn_t start_offset, const char * filename, int flags, int mode) {
stasis_handle_t * ret = malloc(sizeof(stasis_handle_t));
if(!ret) { return NULL; }
*ret = file_func;

115
src/stasis/io/handle.c Normal file
View file

@ -0,0 +1,115 @@
/*
* handle.c
*
* Created on: May 7, 2009
* Author: sears
*/
#include <config.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stasis/io/handle.h>
// @todo this factory stuff doesn't really belong here...
static stasis_handle_t * fast_factory(lsn_t off, lsn_t len, void * ignored) {
stasis_handle_t * h = stasis_handle(open_memory)(off);
//h = stasis_handle(open_debug)(h);
stasis_write_buffer_t * w = h->append_buffer(h, len);
w->h->release_write_buffer(w);
return h;
}
typedef struct sf_args {
const char * filename;
int openMode;
int filePerm;
} sf_args;
static stasis_handle_t * slow_file_factory(void * argsP) {
sf_args * args = (sf_args*) argsP;
stasis_handle_t * h = stasis_handle(open_file)(0, args->filename, args->openMode, args->filePerm);
//h = stasis_handle(open_debug)(h);
return h;
}
static void slow_file_factory_close(void * argsP) {
// nop
}
static stasis_handle_t * slow_pfile_factory(void * argsP) {
stasis_handle_t * h = argsP;
return h;
}
static void slow_pfile_factory_close(void * argsP) {
stasis_handle_t * h = argsP;
h->close(h);
}
static int (*slow_close)(stasis_handle_t * h) = 0;
static stasis_handle_t * slow_pfile = 0;
static int nop_close(stasis_handle_t*h) { return 0; }
stasis_handle_t * stasis_handle(open)(const char * path) {
#ifndef HAVE_O_DIRECT
if(bufferManagerO_DIRECT) {
printf("O_DIRECT not supported by this build; switching to conventional buffered I/O.\n");
bufferManagerO_DIRECT = 0;
}
#endif
int openMode;
if(bufferManagerO_DIRECT) {
#ifdef HAVE_O_DIRECT
openMode = O_CREAT | O_RDWR | O_DIRECT;
#else
printf("Can't happen\n");
abort();
#endif
} else {
openMode = O_CREAT | O_RDWR;
}
stasis_handle_t * ret;
/// @todo remove hardcoding of buffer manager implementations in transactional2.c
switch(bufferManagerFileHandleType) {
case BUFFER_MANAGER_FILE_HANDLE_NON_BLOCKING: {
struct sf_args * slow_arg = malloc(sizeof(sf_args));
slow_arg->filename = path;
slow_arg->openMode = openMode;
slow_arg->filePerm = FILE_PERM;
// Allow 4MB of outstanding writes.
// @todo Where / how should we open storefile?
int worker_thread_count = 4;
if(bufferManagerNonBlockingSlowHandleType == IO_HANDLE_PFILE) {
// printf("\nusing pread()/pwrite()\n");
slow_pfile = stasis_handle_open_pfile(0, slow_arg->filename, slow_arg->openMode, slow_arg->filePerm);
slow_close = slow_pfile->close;
slow_pfile->close = nop_close;
ret =
stasis_handle(open_non_blocking)(slow_pfile_factory, slow_pfile_factory_close, slow_pfile, 1, fast_factory,
NULL, worker_thread_count, PAGE_SIZE * 1024 , 1024);
} else if(bufferManagerNonBlockingSlowHandleType == IO_HANDLE_FILE) {
ret =
stasis_handle(open_non_blocking)(slow_file_factory, slow_file_factory_close, slow_arg, 0, fast_factory,
NULL, worker_thread_count, PAGE_SIZE * 1024, 1024);
} else {
printf("Unknown value for config option bufferManagerNonBlockingSlowHandleType\n");
abort();
}
} break;
case BUFFER_MANAGER_FILE_HANDLE_FILE: {
ret = stasis_handle_open_file(0, path, openMode, FILE_PERM);
} break;
case BUFFER_MANAGER_FILE_HANDLE_PFILE: {
ret = stasis_handle_open_pfile(0, path, openMode, FILE_PERM);
} break;
case BUFFER_MANAGER_FILE_HANDLE_DEPRECATED: {
assert(bufferManagerFileHandleType != BUFFER_MANAGER_FILE_HANDLE_DEPRECATED);
} break;
default: {
printf("\nUnknown buffer manager filehandle type: %d\n",
bufferManagerFileHandleType);
abort();
}
}
return ret;
}

10
src/stasis/io/non_blocking.c
View file

@ -145,6 +145,7 @@ typedef struct nbw_impl {
// Fields to manage slow handles
stasis_handle_t * (*slow_factory)(void * arg);
void (*slow_factory_close)(void * arg);
void * slow_factory_arg;
int slow_force_once;
@ -362,6 +363,10 @@ static int nbw_close(stasis_handle_t * h) {
free(impl->all_slow_handles);
assert(impl->available_slow_handle_count == 0);
if(impl->slow_factory_close) {
impl->slow_factory_close(impl->slow_factory_arg);
}
free(h->impl);
free(h);
return 0;
@ -777,7 +782,9 @@ static void * nbw_worker(void * handle) {
}
stasis_handle_t * stasis_handle(open_non_blocking)
(stasis_handle_t * (*slow_factory)(void * arg), void * slow_factory_arg,
(stasis_handle_t * (*slow_factory)(void * arg),
void (*slow_factory_close)(void * arg),
void * slow_factory_arg,
int slow_force_once,
stasis_handle_t * (*fast_factory)(lsn_t, lsn_t, void *),
void * fast_factory_arg, int worker_thread_count, lsn_t buffer_size,
@ -789,6 +796,7 @@ stasis_handle_t * stasis_handle(open_non_blocking)
impl->end_pos = 0;
impl->slow_factory = slow_factory;
impl->slow_factory_close = slow_factory_close;
impl->slow_factory_arg = slow_factory_arg;
impl->slow_force_once = slow_force_once;

2
src/stasis/io/pfile.c
View file

@ -442,7 +442,7 @@ struct stasis_handle_t pfile_func = {
};
stasis_handle_t *stasis_handle(open_pfile)(lsn_t start_offset,
char *filename,
const char *filename,
int flags, int mode) {
stasis_handle_t *ret = malloc(sizeof(stasis_handle_t));
if (!ret) { return NULL; }

4
src/stasis/page/header.c
View file

@ -1,5 +1,5 @@
#include "../page.h"
#include "header.h"
#include <stasis/page.h>
#include <stasis/page/header.h>
#include <assert.h>
/**
@file header.c is dead code(?)

125
src/stasis/transactional2.c
View file

@ -1,7 +1,4 @@
#include <config.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stasis/common.h>
#include <stasis/latches.h>
@ -24,7 +21,7 @@
#include <stasis/truncation.h>
#include <stasis/io/handle.h>
#include <stasis/blobManager.h> // XXX remove this, move Tread() to set.c
#include <stdio.h>
//#include <stdio.h>
#include <assert.h>
#include <limits.h>
@ -53,33 +50,6 @@ void stasis_transaction_table_init() {
}
}
// @todo this factory stuff doesn't really belong here...
static stasis_handle_t * fast_factory(lsn_t off, lsn_t len, void * ignored) {
stasis_handle_t * h = stasis_handle(open_memory)(off);
//h = stasis_handle(open_debug)(h);
stasis_write_buffer_t * w = h->append_buffer(h, len);
w->h->release_write_buffer(w);
return h;
}
typedef struct sf_args {
char * filename;
int openMode;
int filePerm;
} sf_args;
static stasis_handle_t * slow_file_factory(void * argsP) {
sf_args * args = (sf_args*) argsP;
stasis_handle_t * h = stasis_handle(open_file)(0, args->filename, args->openMode, args->filePerm);
//h = stasis_handle(open_debug)(h);
return h;
}
static stasis_handle_t * slow_pfile_factory(void * argsP) {
stasis_handle_t * h = argsP;
return h;
}
static int (*slow_close)(stasis_handle_t * h) = 0;
static stasis_handle_t * slow_pfile = 0;
static int nop_close(stasis_handle_t*h) { return 0; }
int Tinit() {
pthread_mutex_init(&stasis_transaction_table_mutex, NULL);
stasis_initted = 1;
@ -101,81 +71,15 @@ int Tinit() {
}
stasis_page_init();
#ifndef HAVE_O_DIRECT
if(bufferManagerO_DIRECT) {
printf("O_DIRECT not supported by this build; switching to conventional buffered I/O.\n");
bufferManagerO_DIRECT = 0;
}
#endif
int openMode;
if(bufferManagerO_DIRECT) {
#ifdef HAVE_O_DIRECT
openMode = O_CREAT | O_RDWR | O_DIRECT;
#else
printf("Can't happen\n");
abort();
#endif
} else {
openMode = O_CREAT | O_RDWR;
}
/// @todo remove hardcoding of buffer manager implementations in transactional2.c
switch(bufferManagerFileHandleType) {
case BUFFER_MANAGER_FILE_HANDLE_NON_BLOCKING: {
struct sf_args * slow_arg = malloc(sizeof(sf_args));
slow_arg->filename = stasis_store_file_name;
slow_arg->openMode = openMode;
slow_arg->filePerm = FILE_PERM;
// Allow 4MB of outstanding writes.
// @todo Where / how should we open storefile?
stasis_handle_t * pageFile;
int worker_thread_count = 4;
if(bufferManagerNonBlockingSlowHandleType == IO_HANDLE_PFILE) {
// printf("\nusing pread()/pwrite()\n");
slow_pfile = stasis_handle_open_pfile(0, slow_arg->filename, slow_arg->openMode, slow_arg->filePerm);
slow_close = slow_pfile->close;
slow_pfile->close = nop_close;
pageFile =
stasis_handle(open_non_blocking)(slow_pfile_factory, slow_pfile, 1, fast_factory,
NULL, worker_thread_count, PAGE_SIZE * 1024 , 1024);
} else if(bufferManagerNonBlockingSlowHandleType == IO_HANDLE_FILE) {
pageFile =
stasis_handle(open_non_blocking)(slow_file_factory, slow_arg, 0, fast_factory,
NULL, worker_thread_count, PAGE_SIZE * 1024, 1024);
} else {
printf("Unknown value for config option bufferManagerNonBlockingSlowHandleType\n");
abort();
}
//pageFile = stasis_handle(open_debug)(pageFile);
pageHandleOpen(pageFile);
} break;
case BUFFER_MANAGER_FILE_HANDLE_FILE: {
stasis_handle_t * pageFile =
stasis_handle_open_file(0, stasis_store_file_name,
openMode, FILE_PERM);
pageHandleOpen(pageFile);
} break;
case BUFFER_MANAGER_FILE_HANDLE_PFILE: {
stasis_handle_t * pageFile =
stasis_handle_open_pfile(0, stasis_store_file_name,
openMode, FILE_PERM);
pageHandleOpen(pageFile);
} break;
case BUFFER_MANAGER_FILE_HANDLE_DEPRECATED: {
if(bufferManagerFileHandleType == BUFFER_MANAGER_FILE_HANDLE_DEPRECATED) {
printf("\nWarning: Using old I/O routines (with known bugs).\n");
openPageFile();
} break;
default: {
printf("\nUnknown buffer manager filehandle type: %d\n",
bufferManagerFileHandleType);
abort();
} else {
stasis_handle_t * h = stasis_handle_open(stasis_store_file_name);
// XXX should not be global.
pageHandleOpen(h);
}
}
bufInit(bufferManagerType);
stasis_buffer_manager_open(bufferManagerType);
DEBUG("Buffer manager type = %d\n", bufferManagerType);
pageOperationsInit();
TallocInit();
@ -441,14 +345,9 @@ int Tdeinit() {
stasis_truncation_deinit();
TnaiveHashDeinit();
TallocDeinit();
bufDeinit();
stasis_buffer_manager_close();
DEBUG("Closing page file tdeinit\n");
closePageFile();
if(slow_pfile) {
slow_close(slow_pfile);
slow_pfile = 0;
slow_close = 0;
}
stasis_page_deinit();
stasis_log_file->close(stasis_log_file);
dirtyPagesDeinit();
@ -464,12 +363,8 @@ int TuncleanShutdown() {
stasis_suppress_unclean_shutdown_warnings = 1;
stasis_truncation_deinit();
TnaiveHashDeinit();
simulateBufferManagerCrash();
if(slow_pfile) {
slow_close(slow_pfile);
slow_pfile = 0;
slow_close = 0;
}
stasis_buffer_manager_simulate_crash();
// XXX: closePageFile?
stasis_page_deinit();
stasis_log_file->close(stasis_log_file);
stasis_transaction_table_num_active = 0;

10
stasis/bufferManager.h
View file

@ -99,7 +99,7 @@ Page * loadPage(int xid, pageid_t pageid);
Page * loadUninitializedPage(int xid, pageid_t pageid);
/**
This is the function pointer that bufInit sets in order to
This is the function pointer that stasis_buffer_manager_open sets in order to
override loadPage.
*/
extern Page * (*loadPageImpl)(int xid, pageid_t pageid);
@ -111,7 +111,7 @@ extern Page * (*loadUninitPageImpl)(int xid, pageid_t pageid);
void releasePage(Page *p);
/**
This is the function pointer that bufInit sets in order to
This is the function pointer that stasis_buffer_manager_open sets in order to
override releasePage.
*/
extern void (*releasePageImpl)(Page * p);
@ -146,14 +146,14 @@ extern void (*forcePages)();
This does not force page that have not been written to with pageWrite().
*/
extern void (*forcePageRange)(pageid_t start, pageid_t stop);
extern void (*simulateBufferManagerCrash)();
extern void (*stasis_buffer_manager_simulate_crash)();
int bufInit(int type);
int stasis_buffer_manager_open(int type);
/**
* will write out any dirty pages, assumes that there are no running
* transactions
*/
extern void (*bufDeinit)();
extern void (*stasis_buffer_manager_close)();
#ifdef PROFILE_LATCHES_WRITE_ONLY
#define loadPage(x,y) __profile_loadPage((x), (y), __FILE__, __LINE__)

2
stasis/bufferManager/bufferHash.h
View file

@ -1 +1 @@
void bhBufInit();
void stasis_buffer_manager_hash_open();

2
stasis/bufferManager/legacy/legacyBufferManager.h
View file

@ -1,4 +1,4 @@
#ifndef __STASIS_BUFFERMANAGER_LEGACY_LEGACYBUFFERMANAGER_H
#define __STASIS_BUFFERMANAGER_LEGACY_LEGACYBUFFERMANAGER_H
int bufManBufInit();
int stasis_buffer_manager_deprecated_open();
#endif//__STASIS_BUFFERMANAGER_LEGACY_LEGACYBUFFERMANAGER_H

2
stasis/bufferManager/pageArray.h
View file

@ -1 +1 @@
void paBufInit();
void stasis_buffer_manager_mem_array_open();

12
stasis/io/handle.h
View file

@ -263,7 +263,7 @@ stasis_handle_t * stasis_handle(open_memory)(lsn_t start_offset);
@param perm The file permissions to be passed to open()
*/
stasis_handle_t * stasis_handle(open_file)
(lsn_t start_offset, char * path, int flags, int perm);
(lsn_t start_offset, const char * path, int flags, int perm);
/**
Open a handle that is backed by a file. This handle uses pread()
and pwrite(). It never holds a mutex while perfoming I/O.
@ -278,7 +278,7 @@ stasis_handle_t * stasis_handle(open_file)
@param perm The file permissions to be passed to open()
*/
stasis_handle_t * stasis_handle(open_pfile)
(lsn_t start_offset, char * path, int flags, int perm);
(lsn_t start_offset, const char * path, int flags, int perm);
/**
Given a factory for creating "fast" and "slow" handles, provide a
handle that never makes callers wait for write requests to
@ -326,7 +326,9 @@ stasis_handle_t * stasis_handle(open_pfile)
before blocking.
*/
stasis_handle_t * stasis_handle(open_non_blocking)
(stasis_handle_t * (*slow_factory)(void * arg), void * slow_factory_arg,
(stasis_handle_t * (*slow_factory)(void * arg),
void (*slow_factory_close)(void * arg),
void * slow_factory_arg,
int slow_force_once,
stasis_handle_t * (*fast_factory)(lsn_t off, lsn_t len, void * arg),
void * fast_factory_arg, int worker_thread_count, lsn_t buffer_size,
@ -341,5 +343,9 @@ stasis_handle_t * stasis_handle(open_verifying)(stasis_handle_t * h);
@param h All handle operations will be forwarded to h.
*/
stasis_handle_t * stasis_handle(open_debug)(stasis_handle_t * h);
/**
* Open a Stasis file handle using default arguments.
*/
stasis_handle_t * stasis_handle(open)(const char * path);
#endif

6
test/stasis/check_io.c
View file

@ -426,7 +426,7 @@ START_TEST(io_nonBlockingTest) {
FILE_PERM
};
h = stasis_handle(open_non_blocking)(slow_factory, &slow_args, 0,
h = stasis_handle(open_non_blocking)(slow_factory, 0, &slow_args, 0,
fast_factory, 0,
5, 1024*1024, 100);
// h = stasis_handle(open_debug)(h);
@ -435,7 +435,7 @@ START_TEST(io_nonBlockingTest) {
unlink("logfile.txt");
h = stasis_handle(open_non_blocking)(slow_factory, &slow_args, 0,
h = stasis_handle(open_non_blocking)(slow_factory, 0, &slow_args, 0,
fast_factory, 0,
5, 1024*1024, 100);
//h = stasis_handle(open_debug)(h);
@ -444,7 +444,7 @@ START_TEST(io_nonBlockingTest) {
unlink("logfile.txt");
h = stasis_handle(open_non_blocking)(slow_factory, &slow_args, 0,
h = stasis_handle(open_non_blocking)(slow_factory, 0, &slow_args, 0,
fast_factory, 0,
5, 1024 * 1024, 100);
handle_concurrencytest(h);