Re: patch for new feature: Buffer Cache Hibernation

Should this be marked as TODO?

---------------------------------------------------------------------------

Mitsuru IWASAKI wrote:
> Hi,
>
> > On 05/07/2011 03:32 AM, Mitsuru IWASAKI wrote:
> > > For 1, I've just finish my work. The latest patch is available at:
> > > http://people.freebsd.org/~iwasaki/postgres/buffer-cache-hibernation-postgresql-20110507.patch
> > >
> >
> > Reminder here--we can't accept code based on it being published to a web
> > page. You'll need to e-mail it to the pgsql-hackers mailing list to be
> > considered for the next PostgreSQL CommitFest, which is starting in a
> > few weeks. Code submitted to the mailing list is considered a release
> > of it to the project under the PostgreSQL license, which we can't just
> > assume for things when given only a URL to them.
>
> Sorry about that, but I had enough time to revise my patches this week-end.
> I attached the patches in this mail, and will update CommitFest page soon.
>
> > Also, you suggested you were out of time to work on this. If that's the
> > case, we'd like to know that so we don't keep cc'ing you about things in
> > expectation of an answer. Someone else may pick this up as a project to
> > continue working on. But it's going to need a fair amount of revision
> > before it matches what people want here, and I'm not sure how much of
> > what you've written is going to end up in any commit that may happen
> > from this idea.
>
> It seems that I don't have enough time to complete this work.
> You don't need to keep cc'ing me, and I'm very happy if postgres to be
> the first DBMS which support buffer cache hibernation feature.
>
> Thanks!
>
>
> diff --git src/backend/access/transam/xlog.c src/backend/access/transam/xlog.c
> index b0e4c41..7a3a207 100644
> --- src/backend/access/transam/xlog.c
> +++ src/backend/access/transam/xlog.c
> @@ -4834,6 +4834,19 @@ ReadControlFile(void)
> #endif
> }
>
> +bool
> +GetControlFile(ControlFileData *controlFile)
> +{
> + if (ControlFile == NULL)
> + {
> + return false;
> + }
> +
> + memcpy(controlFile, ControlFile, sizeof(ControlFileData));
> +
> + return true;
> +}
> +
> void
> UpdateControlFile(void)
> {
> diff --git src/backend/bootstrap/bootstrap.c src/backend/bootstrap/bootstrap.c
> index fc093cc..7ecf6bb 100644
> --- src/backend/bootstrap/bootstrap.c
> +++ src/backend/bootstrap/bootstrap.c
> @@ -360,6 +360,15 @@ AuxiliaryProcessMain(int argc, char *argv[])
> BaseInit();
>
> /*
> + * Only StartupProcess can call ResumeBufferCacheHibernation() after
> + * InitFileAccess() and smgrinit().
> + */
> + if (auxType == StartupProcess && BufferCacheHibernationLevel > 0)
> + {
> + ResumeBufferCacheHibernation();
> + }
> +
> + /*
> * When we are an auxiliary process, we aren't going to do the full
> * InitPostgres pushups, but there are a couple of things that need to get
> * lit up even in an auxiliary process.
> diff --git src/backend/storage/buffer/buf_init.c src/backend/storage/buffer/buf_init.c
> index dadb49d..52eb51a 100644
> --- src/backend/storage/buffer/buf_init.c
> +++ src/backend/storage/buffer/buf_init.c
> @@ -127,6 +127,14 @@ InitBufferPool(void)
>
> /* Init other shared buffer-management stuff */
> StrategyInitialize(!foundDescs);
> +
> + if (BufferCacheHibernationLevel > 0)
> + {
> + ResisterBufferCacheHibernation(BUFFER_CACHE_HIBERNATION_TYPE_DESCRIPTORS,
> + (char *)BufferDescriptors, sizeof(BufferDesc), NBuffers);
> + ResisterBufferCacheHibernation(BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS,
> + (char *)BufferBlocks, BLCKSZ, NBuffers);
> + }
> }
>
> /*
> diff --git src/backend/storage/buffer/bufmgr.c src/backend/storage/buffer/bufmgr.c
> index f96685d..dba8ebf 100644
> --- src/backend/storage/buffer/bufmgr.c
> +++ src/backend/storage/buffer/bufmgr.c
> @@ -31,6 +31,7 @@
> #include "postgres.h"
>
> #include <sys/file.h>
> +#include <sys/stat.h>
> #include <unistd.h>
>
> #include "catalog/catalog.h"
> @@ -61,6 +62,13 @@
> #define BUF_WRITTEN 0x01
> #define BUF_REUSABLE 0x02
>
> +/*
> + * Buffer Cache Hibernation stuff.
> + */
> +/* enable this to debug buffer cache hibernation. */
> +#if 0
> +#define DEBUG_BUFFER_CACHE_HIBERNATION
> +#endif
>
> /* GUC variables */
> bool zero_damaged_pages = false;
> @@ -765,6 +773,16 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
> }
> }
>
> +#ifdef DEBUG_BUFFER_CACHE_HIBERNATION
> + elog(DEBUG5,
> + "alloc [%d]\t%03x,%d,%d,%d,%d\t%08x,%d,%d,%d,%d,%d",
> + buf->buf_id, buf->flags, buf->usage_count, buf->refcount,
> + buf->wait_backend_pid, buf->freeNext,
> + newHash, newTag.rnode.spcNode,
> + newTag.rnode.dbNode, newTag.rnode.relNode,
> + newTag.forkNum, newTag.blockNum);
> +#endif
> +
> return buf;
> }
>
> @@ -800,6 +818,16 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
> * the old content is no longer relevant. (The usage_count starts out at
> * 1 so that the buffer can survive one clock-sweep pass.)
> */
> +#ifdef DEBUG_BUFFER_CACHE_HIBERNATION
> + elog(DEBUG5,
> + "rename [%d]\t%03x,%d,%d,%d,%d\t%08x,%d,%d,%d,%d,%d",
> + buf->buf_id, buf->flags, buf->usage_count, buf->refcount,
> + buf->wait_backend_pid, buf->freeNext,
> + oldHash, oldTag.rnode.spcNode,
> + oldTag.rnode.dbNode, oldTag.rnode.relNode,
> + oldTag.forkNum, oldTag.blockNum);
> +#endif
> +
> buf->tag = newTag;
> buf->flags &= ~(BM_VALID | BM_DIRTY | BM_JUST_DIRTIED | BM_CHECKPOINT_NEEDED | BM_IO_ERROR | BM_PERMANENT);
> if (relpersistence == RELPERSISTENCE_PERMANENT)
> @@ -2772,3 +2800,716 @@ local_buffer_write_error_callback(void *arg)
> pfree(path);
> }
> }
> +
> +/* ----------------------------------------------------------------
> + * Buffer Cache Hibernation support stuff
> + *
> + * Suspend/resume buffer cache data structure using hibernation files
> + * at shutdown/startup.
> + * ----------------------------------------------------------------
> + */
> +
> +int BufferCacheHibernationLevel = 0;
> +
> +#define BUFFER_CACHE_HIBERNATION_FILE_STRATEGY "global/pg_buffer_cache_hibernation_strategy"
> +#define BUFFER_CACHE_HIBERNATION_FILE_DESCRIPTORS "global/pg_buffer_cache_hibernation_descriptors"
> +#define BUFFER_CACHE_HIBERNATION_FILE_BLOCKS "global/pg_buffer_cache_hibernation_blocks"
> +#define BUFFER_CACHE_HIBERNATION_FILE_CRC32 "global/pg_buffer_cache_hibernation_crc32"
> +
> +static struct
> +{
> + char *hibernation_file;
> + char *data_ptr;
> + Size record_length;
> + Size num_records;
> + pg_crc32 crc;
> +} BufferCacheHibernationData[] =
> +{
> + /* BufferStrategyControl */
> + {
> + BUFFER_CACHE_HIBERNATION_FILE_STRATEGY,
> + NULL, 0, 0, 0
> + },
> +
> + /* BufferDescriptors */
> + {
> + BUFFER_CACHE_HIBERNATION_FILE_DESCRIPTORS,
> + NULL, 0, 0, 0
> + },
> +
> + /* BufferBlocks */
> + {
> + BUFFER_CACHE_HIBERNATION_FILE_BLOCKS,
> + NULL, 0, 0, 0
> + },
> +
> + /* End-of-list marker */
> + {
> + NULL,
> + NULL, 0, 0, 0
> + },
> +};
> +
> +static ControlFileData controlFile;
> +static bool controlFileInitialized = false;
> +
> +/*
> + * AtProcExit_BufferCacheHibernation:
> + * store the buffer cache into hibernation files at shutdown.
> + */
> +static void
> +AtProcExit_BufferCacheHibernation(int code, Datum arg)
> +{
> + BufferHibernationFileType id;
> + int i;
> + int fd;
> +
> + if (BufferCacheHibernationLevel == 0)
> + {
> + return;
> + }
> +
> + /*
> + * get the control file to check the system state validation.
> + */
> + if (GetControlFile(&controlFile) == false)
> + {
> + elog(WARNING,
> + "could not get control file, "
> + "aborting buffer cache hibernation");
> + return;
> + }
> +
> + if (controlFile.state != DB_SHUTDOWNED)
> + {
> + elog(WARNING,
> + "database system was not shut down normally, "
> + "aborting buffer cache hibernation");
> + return;
> + }
> +
> + /*
> + * suspend buffer cache data structure into hibernation files.
> + */
> + for (id = 0; BufferCacheHibernationData[id].hibernation_file != NULL; id++)
> + {
> + Size record_length;
> + Size num_records;
> + char *ptr;
> + pg_crc32 crc;
> +
> + if (BufferCacheHibernationLevel < 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + continue;
> + }
> +
> + if (BufferCacheHibernationData[id].data_ptr == NULL ||
> + BufferCacheHibernationData[id].record_length == 0 ||
> + BufferCacheHibernationData[id].num_records == 0)
> + {
> + elog(WARNING,
> + "ResisterBufferCacheHibernation() was not called for %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + goto cleanup;
> + }
> +
> + fd = BasicOpenFile(BufferCacheHibernationData[id].hibernation_file,
> + O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, S_IRUSR | S_IWUSR);
> + if (fd < 0)
> + {
> + elog(WARNING,
> + "could not open %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + goto cleanup;
> + }
> +
> + record_length = BufferCacheHibernationData[id].record_length;
> + num_records = BufferCacheHibernationData[id].num_records;
> +
> + elog(NOTICE,
> + "buffer cache hibernate into %s",
> + BufferCacheHibernationData[id].hibernation_file);
> +
> + INIT_CRC32(crc);
> + for (i = 0; i < num_records; i++)
> + {
> + ptr = BufferCacheHibernationData[id].data_ptr + (i * record_length);
> + if (write(fd, (void *)ptr, record_length) != record_length)
> + {
> + elog(WARNING,
> + "could not write %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + goto cleanup;
> + }
> +
> + COMP_CRC32(crc, ptr, record_length);
> + }
> +
> + FIN_CRC32(crc);
> + close(fd);
> +
> + BufferCacheHibernationData[id].crc = crc;
> + }
> +
> + /*
> + * save the computed crc values for the validations at resuming.
> + */
> + fd = BasicOpenFile(BUFFER_CACHE_HIBERNATION_FILE_CRC32,
> + O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY, S_IRUSR | S_IWUSR);
> + if (fd < 0)
> + {
> + elog(WARNING,
> + "could not open %s",
> + BUFFER_CACHE_HIBERNATION_FILE_CRC32);
> + goto cleanup;
> + }
> +
> + for (id = 0; BufferCacheHibernationData[id].hibernation_file != NULL; id++)
> + {
> + pg_crc32 crc;
> +
> + if (BufferCacheHibernationLevel < 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + continue;
> + }
> +
> + crc = BufferCacheHibernationData[id].crc;
> + if (write(fd, (void *)&crc, sizeof(pg_crc32)) != sizeof(pg_crc32))
> + {
> + elog(WARNING,
> + "could not write %s for %s",
> + BUFFER_CACHE_HIBERNATION_FILE_CRC32,
> + BufferCacheHibernationData[id].hibernation_file);
> + goto cleanup;
> + }
> + }
> + close(fd);
> +
> + elog(NOTICE,
> + "buffer cache suspended successfully");
> +
> + return;
> +
> +cleanup:
> + for (id = 0; BufferCacheHibernationData[id].hibernation_file != NULL; id++)
> + {
> + unlink(BufferCacheHibernationData[id].hibernation_file);
> + }
> +
> + return;
> +}
> +
> +/*
> + * ResisterBufferCacheHibernation:
> + * register the buffer cache data structure info.
> + */
> +void
> +ResisterBufferCacheHibernation(BufferHibernationFileType id, char *ptr, Size record_length, Size num_records)
> +{
> + static bool first_time = true;
> +
> + if (BufferCacheHibernationLevel == 0)
> + {
> + return;
> + }
> +
> + if (id != BUFFER_CACHE_HIBERNATION_TYPE_STRATEGY &&
> + id != BUFFER_CACHE_HIBERNATION_TYPE_DESCRIPTORS &&
> + id != BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + return;
> + }
> +
> + if (first_time)
> + {
> + /*
> + * AtProcExit_BufferCacheHibernation to be called at shutdown.
> + */
> + on_shmem_exit(AtProcExit_BufferCacheHibernation, 0);
> + first_time = false;
> + }
> +
> + /*
> + * get the control file to check the system state and
> + * hibernation file validations.
> + */
> + if (controlFileInitialized == false)
> + {
> + if (GetControlFile(&controlFile) == true)
> + {
> + controlFileInitialized = true;
> + }
> + }
> +
> + BufferCacheHibernationData[id].data_ptr = ptr;
> + BufferCacheHibernationData[id].record_length = record_length;
> + BufferCacheHibernationData[id].num_records = num_records;
> +}
> +
> +/*
> + * ResumeBufferCacheHibernation:
> + * resume the buffer cache from hibernation file at startup.
> + */
> +void
> +ResumeBufferCacheHibernation(void)
> +{
> + BufferHibernationFileType id;
> + int i;
> + int fd;
> + Size num_records;
> + Size record_length;
> + char *buf_common;
> + int oldNBuffers;
> + bool buffer_block_processed;
> +
> + if (BufferCacheHibernationLevel == 0)
> + {
> + return;
> + }
> +
> + buf_common = NULL;
> + buffer_block_processed = false;
> +
> + /*
> + * lock all buffer descriptors to prevent other processes from
> + * updating buffers.
> + */
> + for (i = 0; i < NBuffers; i++)
> + {
> + BufferDesc *buf;
> +
> + buf = &BufferDescriptors[i];
> + LockBufHdr(buf);
> + }
> +
> + /*
> + * get the control file to check the system state and
> + * hibernation file validations.
> + */
> + if (controlFileInitialized == false)
> + {
> + elog(WARNING,
> + "could not get control file, "
> + "aborting buffer cache hibernation");
> + goto cleanup;
> + }
> +
> + if (controlFile.state != DB_SHUTDOWNED)
> + {
> + elog(WARNING,
> + "database system was not shut down normally, "
> + "aborting buffer cache hibernation");
> + goto cleanup;
> + }
> +
> + /*
> + * read the crc values which was computed when the hibernation
> + * files were created.
> + */
> + fd = BasicOpenFile(BUFFER_CACHE_HIBERNATION_FILE_CRC32,
> + O_RDONLY | PG_BINARY, S_IRUSR | S_IWUSR);
> + if (fd < 0)
> + {
> + elog(WARNING,
> + "could not open %s",
> + BUFFER_CACHE_HIBERNATION_FILE_CRC32);
> + goto cleanup;
> + }
> +
> + for (id = 0; BufferCacheHibernationData[id].hibernation_file != NULL; id++)
> + {
> + pg_crc32 crc;
> +
> + if (BufferCacheHibernationLevel < 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + continue;
> + }
> +
> + if (read(fd, (void *)&crc, sizeof(pg_crc32)) != sizeof(pg_crc32))
> + {
> + if (BufferCacheHibernationLevel == 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + /*
> + * if buffer_cache_hibernation_level changes 1 to 2,
> + * the crc value of buffer block hibernation file may not exist.
> + * just ignore it here.
> + */
> + continue;
> + }
> +
> + elog(WARNING,
> + "could not read %s for %s",
> + BUFFER_CACHE_HIBERNATION_FILE_CRC32,
> + BufferCacheHibernationData[id].hibernation_file);
> + close(fd);
> + goto cleanup;
> + }
> + BufferCacheHibernationData[id].crc = crc;
> + }
> +
> + close(fd);
> +
> + /*
> + * allocate a buffer to read the contents of the hibernation files
> + * for validations.
> + */
> + record_length = 0;
> + for (id = 0; BufferCacheHibernationData[id].hibernation_file != NULL; id++)
> + {
> + if (record_length < BufferCacheHibernationData[id].record_length)
> + {
> + record_length = BufferCacheHibernationData[id].record_length;
> + }
> + }
> +
> + buf_common = malloc(record_length);
> + Assert(buf_common != NULL);
> +
> + /* assume that the number of buffers have not changed. */
> + oldNBuffers = NBuffers;
> +
> + /*
> + * check if all hibernation files are valid.
> + */
> + for (id = 0; BufferCacheHibernationData[id].hibernation_file != NULL; id++)
> + {
> + struct stat sb;
> + pg_crc32 crc;
> +
> + if (BufferCacheHibernationLevel < 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + continue;
> + }
> +
> + if (BufferCacheHibernationData[id].data_ptr == NULL ||
> + BufferCacheHibernationData[id].record_length == 0 ||
> + BufferCacheHibernationData[id].num_records == 0)
> + {
> + elog(WARNING,
> + "ResisterBufferCacheHibernation() was not called for %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + goto cleanup;
> + }
> +
> + fd = BasicOpenFile(BufferCacheHibernationData[id].hibernation_file,
> + O_RDONLY | PG_BINARY, S_IRUSR | S_IWUSR);
> + if (fd < 0)
> + {
> + if (BufferCacheHibernationLevel == 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + /*
> + * if buffer_cache_hibernation_level changes 1 to 2,
> + * the buffer block hibernation file may not exist.
> + * just ignore it here.
> + */
> + continue;
> + }
> +
> + goto cleanup;
> + }
> +
> + if (fstat(fd, &sb) < 0)
> + {
> + elog(WARNING,
> + "could not get stats of the buffer cache hibernation file: %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + close(fd);
> + goto cleanup;
> + }
> +
> + record_length = BufferCacheHibernationData[id].record_length;
> + num_records = BufferCacheHibernationData[id].num_records;
> +
> + if (sb.st_size != (record_length * num_records))
> + {
> + /* The size of StrategyControl should be the same always. */
> + if (id == BUFFER_CACHE_HIBERNATION_TYPE_STRATEGY ||
> + (sb.st_size % record_length) > 0)
> + {
> + elog(WARNING,
> + "size mismatch on the buffer cache hibernation file: %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + close(fd);
> + goto cleanup;
> + }
> +
> + /*
> + * The number of records of buffer descriptors and blocks
> + * should be the same.
> + */
> + if (oldNBuffers != NBuffers &&
> + oldNBuffers != (sb.st_size / record_length))
> + {
> + elog(WARNING,
> + "size mismatch on the buffer cache hibernation file: %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + close(fd);
> + goto cleanup;
> + }
> +
> + oldNBuffers = sb.st_size / record_length;
> +
> + elog(NOTICE,
> + "shared_buffers have changed from %d to %d: %s",
> + oldNBuffers, NBuffers,
> + BufferCacheHibernationData[id].hibernation_file);
> +
> + /* use the original size to compute CRC of the hibernation file. */
> + num_records = oldNBuffers;
> + }
> +
> + if ((pg_time_t)sb.st_mtime < controlFile.time)
> + {
> + elog(WARNING,
> + "the hibernation file is older than control file: %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + close(fd);
> + goto cleanup;
> + }
> +
> + INIT_CRC32(crc);
> + for (i = 0; i < num_records; i++)
> + {
> + if (read(fd, (void *)buf_common, record_length) != record_length)
> + {
> + elog(WARNING,
> + "could not read the buffer cache hibernation file: %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + close(fd);
> + goto cleanup;
> + }
> +
> + COMP_CRC32(crc, buf_common, record_length);
> +
> + /*
> + * buffer descriptors validations.
> + */
> + if (id == BUFFER_CACHE_HIBERNATION_TYPE_DESCRIPTORS)
> + {
> + BufferDesc *buf;
> + BufFlags abnormal_flags;
> +
> + if (i >= NBuffers)
> + {
> + continue;
> + }
> +
> + abnormal_flags = (BM_DIRTY | BM_IO_IN_PROGRESS | BM_IO_ERROR |
> + BM_JUST_DIRTIED | BM_PIN_COUNT_WAITER);
> +
> + buf = (BufferDesc *)buf_common;
> +
> + if (buf->flags & abnormal_flags)
> + {
> + elog(WARNING,
> + "abnormal flags in buffer descriptors: %d",
> + buf->flags);
> + close(fd);
> + goto cleanup;
> + }
> +
> + if (buf->usage_count > BM_MAX_USAGE_COUNT)
> + {
> + elog(WARNING,
> + "invalid usage count in buffer descriptors: %d",
> + buf->usage_count);
> + close(fd);
> + goto cleanup;
> + }
> +
> + if (buf->buf_id < 0 || buf->buf_id >= num_records)
> + {
> + elog(WARNING,
> + "invalid buffer id in buffer descriptors: %d",
> + buf->buf_id);
> + close(fd);
> + goto cleanup;
> + }
> + }
> + }
> +
> + FIN_CRC32(crc);
> + close(fd);
> +
> + if (!EQ_CRC32(BufferCacheHibernationData[id].crc, crc))
> + {
> + elog(WARNING,
> + "crc mismatch on the buffer cache hibernation file: %s",
> + BufferCacheHibernationData[id].hibernation_file);
> + close(fd);
> + goto cleanup;
> + }
> + }
> +
> + /*
> + * resume the buffer cache data structure from the hibernation files.
> + */
> + for (id = 0; BufferCacheHibernationData[id].hibernation_file != NULL; id++)
> + {
> + int fd;
> + char *ptr;
> +
> + if (BufferCacheHibernationLevel < 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + continue;
> + }
> +
> + record_length = BufferCacheHibernationData[id].record_length;
> + num_records = BufferCacheHibernationData[id].num_records;
> +
> + if (id != BUFFER_CACHE_HIBERNATION_TYPE_STRATEGY)
> + {
> + /* use the smaller number of buffers. */
> + num_records = (oldNBuffers < NBuffers)? oldNBuffers : NBuffers;
> + }
> +
> + fd = BasicOpenFile(BufferCacheHibernationData[id].hibernation_file,
> + O_RDONLY | PG_BINARY, S_IRUSR | S_IWUSR);
> + if (fd < 0)
> + {
> + if (BufferCacheHibernationLevel == 2 &&
> + id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + /*
> + * if buffer_cache_hibernation_level changes 1 to 2,
> + * the buffer block hibernation file may not exist.
> + * just ignore it here.
> + */
> + continue;
> + }
> +
> + goto cleanup;
> + }
> +
> + elog(NOTICE,
> + "buffer cache resume from %s(%d bytes * %d records)",
> + BufferCacheHibernationData[id].hibernation_file,
> + record_length, num_records);
> +
> + for (i = 0; i < num_records; i++)
> + {
> + ptr = BufferCacheHibernationData[id].data_ptr + (i * record_length);
> + read(fd, (void *)ptr, record_length);
> +
> + /* Re-lock the buffer descriptor if necessary. */
> + if (id == BUFFER_CACHE_HIBERNATION_TYPE_DESCRIPTORS)
> + {
> + BufferDesc *buf;
> +
> + buf = (BufferDesc *)ptr;
> + if (IsUnlockBufHdr(buf))
> + {
> + LockBufHdr(buf);
> + }
> + }
> + }
> +
> + close(fd);
> +
> + if (id == BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS)
> + {
> + buffer_block_processed = true;
> + }
> + }
> +
> + if (buffer_block_processed == false)
> + {
> + /* we didn't use the buffer block hibernation file, so delete it now. */
> + id = BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS;
> + unlink(BufferCacheHibernationData[id].hibernation_file);
> + }
> +
> + /*
> + * set the rest data structures (eg. lookup hashtable) up
> + * based on the buffer descriptors.
> + */
> + num_records = (oldNBuffers < NBuffers)? oldNBuffers : NBuffers;
> + for (i = 0; i < num_records; i++)
> + {
> + BufferDesc *buf;
> + BufferTag newTag;
> + uint32 newHash;
> + int buf_id;
> +
> + buf = &BufferDescriptors[i];
> + if (buf->tag.rnode.spcNode == InvalidOid &&
> + buf->tag.rnode.dbNode == InvalidOid &&
> + buf->tag.rnode.relNode == InvalidOid)
> + {
> + continue;
> + }
> +
> + INIT_BUFFERTAG(newTag, buf->tag.rnode, buf->tag.forkNum, buf->tag.blockNum);
> + newHash = BufTableHashCode(&newTag);
> +
> + if (buffer_block_processed == false)
> + {
> + Block bufBlock;
> + SMgrRelation smgr;
> +
> + /*
> + * re-read buffer block.
> + */
> + bufBlock = BufHdrGetBlock(buf);
> + smgr = smgropen(buf->tag.rnode, InvalidBackendId);
> + smgrread(smgr, newTag.forkNum, newTag.blockNum, (char *) bufBlock);
> + }
> +
> + buf_id = BufTableInsert(&newTag, newHash, buf->buf_id);
> + if (buf_id != -1)
> + {
> + /* the entry exists already, return it to the freelist. */
> + buf->refcount = 0;
> + buf->flags = 0;
> + InvalidateBuffer(buf);
> + continue;
> + }
> +
> + /* clear wait_backend_pid because the process was terminated already. */
> + buf->wait_backend_pid = 0;
> +
> +#ifdef DEBUG_BUFFER_CACHE_HIBERNATION
> + elog(DEBUG5,
> + "resume [%d]\t%03x,%d,%d,%d,%d\t%08x,%d,%d,%d,%d,%d",
> + buf->buf_id, buf->flags, buf->usage_count, buf->refcount,
> + buf->wait_backend_pid, buf->freeNext,
> + newHash, newTag.rnode.spcNode,
> + newTag.rnode.dbNode, newTag.rnode.relNode,
> + newTag.forkNum, newTag.blockNum);
> +#endif
> + }
> +
> + /*
> + * adjust StrategyControl based on the change of shared_buffers.
> + */
> + if (oldNBuffers != NBuffers)
> + {
> + AdjustStrategyControl(oldNBuffers);
> + }
> +
> + elog(NOTICE,
> + "buffer cache resumed successfully");
> +
> +cleanup:
> + for (i = 0; i < NBuffers; i++)
> + {
> + BufferDesc *buf;
> +
> + buf = &BufferDescriptors[i];
> + UnlockBufHdr(buf);
> + }
> +
> + if (buf_common != NULL)
> + {
> + free(buf_common);
> + }
> +
> + return;
> +}
> diff --git src/backend/storage/buffer/freelist.c src/backend/storage/buffer/freelist.c
> index bf9903b..ffc101d 100644
> --- src/backend/storage/buffer/freelist.c
> +++ src/backend/storage/buffer/freelist.c
> @@ -347,6 +347,12 @@ StrategyInitialize(bool init)
> }
> else
> Assert(!init);
> +
> + if (BufferCacheHibernationLevel > 0)
> + {
> + ResisterBufferCacheHibernation(BUFFER_CACHE_HIBERNATION_TYPE_STRATEGY,
> + (char *)StrategyControl, sizeof(BufferStrategyControl), 1);
> + }
> }
>
>
> @@ -521,3 +527,47 @@ StrategyRejectBuffer(BufferAccessStrategy strategy, volatile BufferDesc *buf)
>
> return true;
> }
> +
> +/*
> + * AdjustStrategyControl -- adjust the member variables of StrategyControl
> + *
> + * If the shared_buffers setting had changed, restored StrategyControl
> + * needs to be adjusted for in both cases of shrinking and enlarging.
> + * This is called only from bufmgr.c:ResumeBufferCacheHibernation().
> + */
> +void
> +AdjustStrategyControl(int oldNBuffers)
> +{
> + if (oldNBuffers == NBuffers)
> + {
> + return;
> + }
> +
> + /* enlarge or shrink the free buffer based on current NBuffers. */
> + StrategyControl->lastFreeBuffer = NBuffers - 1;
> +
> + /* shared_buffers shrunk. */
> + if (oldNBuffers > NBuffers)
> + {
> + if (StrategyControl->nextVictimBuffer >= NBuffers)
> + {
> + /* set the tail of buffers. */
> + StrategyControl->nextVictimBuffer = NBuffers - 1;
> + }
> +
> + if (StrategyControl->firstFreeBuffer >= NBuffers)
> + {
> + /* set FREENEXT_END_OF_LIST(-1). */
> + StrategyControl->firstFreeBuffer = FREENEXT_END_OF_LIST;
> + }
> + }
> + else
> + /* shared_buffers enlarged. */
> + {
> + if (StrategyControl->firstFreeBuffer < 0)
> + {
> + /* set the next entry of the tail of old buffers. */
> + StrategyControl->firstFreeBuffer = oldNBuffers;
> + }
> + }
> +}
> diff --git src/backend/utils/misc/guc.c src/backend/utils/misc/guc.c
> index 738e215..5affc6e 100644
> --- src/backend/utils/misc/guc.c
> +++ src/backend/utils/misc/guc.c
> @@ -2361,6 +2361,18 @@ static struct config_int ConfigureNamesInt[] =
> NULL, NULL, NULL
> },
>
> + {
> + {"buffer_cache_hibernation_level", PGC_POSTMASTER, UNGROUPED,
> + gettext_noop("Sets buffer cache hibernation level."),
> + gettext_noop("0 to disable(default), "
> + "1 for saving buffer descriptors only(recommended), "
> + "2 for saving buffer descriptors and buffer blocks(slower at shutdown).")
> + },
> + &BufferCacheHibernationLevel,
> + 0, 0, 2,
> + NULL, NULL, NULL
> + },
> +
> /* End-of-list marker */
> {
> {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
> diff --git src/backend/utils/misc/postgresql.conf.sample src/backend/utils/misc/postgresql.conf.sample
> index b8a1582..44b6ff3 100644
> --- src/backend/utils/misc/postgresql.conf.sample
> +++ src/backend/utils/misc/postgresql.conf.sample
> @@ -119,6 +119,17 @@
> #maintenance_work_mem = 16MB # min 1MB
> #max_stack_depth = 2MB # min 100kB
>
> +
> +# Buffer Cache Hibernation:
> +# Suspend/resume buffer cache data structure using hibernation files
> +# at shutdown/startup.
> +#buffer_cache_hibernation_level = 0 # Sets buffer cache hibernation level.
> + # 0 to disable(default),
> + # 1 for saving buffer descriptors only
> + # (recommended),
> + # 2 for saving buffer descriptors and
> + # buffer blocks(slower at shutdown).
> +
> # - Kernel Resource Usage -
>
> #max_files_per_process = 1000 # min 25
> diff --git src/include/access/xlog.h src/include/access/xlog.h
> index 7056fd6..7a9fb99 100644
> --- src/include/access/xlog.h
> +++ src/include/access/xlog.h
> @@ -13,6 +13,7 @@
>
> #include "access/rmgr.h"
> #include "access/xlogdefs.h"
> +#include "catalog/pg_control.h"
> #include "lib/stringinfo.h"
> #include "storage/buf.h"
> #include "utils/pg_crc.h"
> @@ -294,6 +295,7 @@ extern bool XLogInsertAllowed(void);
> extern void GetXLogReceiptTime(TimestampTz *rtime, bool *fromStream);
> extern XLogRecPtr GetXLogReplayRecPtr(void);
>
> +extern bool GetControlFile(ControlFileData *controlFile);
> extern void UpdateControlFile(void);
> extern uint64 GetSystemIdentifier(void);
> extern Size XLOGShmemSize(void);
> diff --git src/include/storage/buf_internals.h src/include/storage/buf_internals.h
> index b7d4ea5..d537ef1 100644
> --- src/include/storage/buf_internals.h
> +++ src/include/storage/buf_internals.h
> @@ -167,6 +167,7 @@ typedef struct sbufdesc
> */
> #define LockBufHdr(bufHdr) SpinLockAcquire(&(bufHdr)->buf_hdr_lock)
> #define UnlockBufHdr(bufHdr) SpinLockRelease(&(bufHdr)->buf_hdr_lock)
> +#define IsUnlockBufHdr(bufHdr) SpinLockFree(&(bufHdr)->buf_hdr_lock)
>
>
> /* in buf_init.c */
> @@ -190,6 +191,7 @@ extern bool StrategyRejectBuffer(BufferAccessStrategy strategy,
> extern int StrategySyncStart(uint32 *complete_passes, uint32 *num_buf_alloc);
> extern Size StrategyShmemSize(void);
> extern void StrategyInitialize(bool init);
> +extern void AdjustStrategyControl(int oldNBuffers);
>
> /* buf_table.c */
> extern Size BufTableShmemSize(int size);
> diff --git src/include/storage/bufmgr.h src/include/storage/bufmgr.h
> index b8fc87e..ddfeb9d 100644
> --- src/include/storage/bufmgr.h
> +++ src/include/storage/bufmgr.h
> @@ -211,6 +211,20 @@ extern void BgBufferSync(void);
>
> extern void AtProcExit_LocalBuffers(void);
>
> +/* buffer cache hibernation support stuff */
> +extern int BufferCacheHibernationLevel;
> +
> +typedef enum BufferHibernationFileType
> +{
> + BUFFER_CACHE_HIBERNATION_TYPE_STRATEGY,
> + BUFFER_CACHE_HIBERNATION_TYPE_DESCRIPTORS,
> + BUFFER_CACHE_HIBERNATION_TYPE_BLOCKS
> +} BufferHibernationFileType;
> +
> +extern void ResisterBufferCacheHibernation(BufferHibernationFileType id,
> + char *ptr, Size record_length, Size num_records);
> +extern void ResumeBufferCacheHibernation(void);
> +
> /* in freelist.c */
> extern BufferAccessStrategy GetAccessStrategy(BufferAccessStrategyType btype);
> extern void FreeAccessStrategy(BufferAccessStrategy strategy);
>
> --
> Sent via pgsql-hackers mailing list (pgsql-hackers(at)postgresql(dot)org)
> To make changes to your subscription:
> http://www.postgresql.org/mailpref/pgsql-hackers

--
Bruce Momjian <bruce(at)momjian(dot)us> http://momjian.us
EnterpriseDB http://enterprisedb.com

+ It's impossible for everything to be true. +