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@postgresql.org)
> To make changes to your subscription:
> http://www.postgresql.org/mailpref/pgsql-hackers

--  Bruce Momjian  <bruce@momjian.us>        http://momjian.us EnterpriseDB
http://enterprisedb.com
 + It's impossible for everything to be true. +