Return to pcache.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src

Annotation of embedaddon/sqlite3/src/pcache.h, revision 1.1

1.1     ! misho       1: /*
        !             2: ** 2008 August 05
        !             3: **
        !             4: ** The author disclaims copyright to this source code.  In place of
        !             5: ** a legal notice, here is a blessing:
        !             6: **
        !             7: **    May you do good and not evil.
        !             8: **    May you find forgiveness for yourself and forgive others.
        !             9: **    May you share freely, never taking more than you give.
        !            10: **
        !            11: *************************************************************************
        !            12: ** This header file defines the interface that the sqlite page cache
        !            13: ** subsystem. 
        !            14: */
        !            15: 
        !            16: #ifndef _PCACHE_H_
        !            17: 
        !            18: typedef struct PgHdr PgHdr;
        !            19: typedef struct PCache PCache;
        !            20: 
        !            21: /*
        !            22: ** Every page in the cache is controlled by an instance of the following
        !            23: ** structure.
        !            24: */
        !            25: struct PgHdr {
        !            26:   sqlite3_pcache_page *pPage;    /* Pcache object page handle */
        !            27:   void *pData;                   /* Page data */
        !            28:   void *pExtra;                  /* Extra content */
        !            29:   PgHdr *pDirty;                 /* Transient list of dirty pages */
        !            30:   Pgno pgno;                     /* Page number for this page */
        !            31:   Pager *pPager;                 /* The pager this page is part of */
        !            32: #ifdef SQLITE_CHECK_PAGES
        !            33:   u32 pageHash;                  /* Hash of page content */
        !            34: #endif
        !            35:   u16 flags;                     /* PGHDR flags defined below */
        !            36: 
        !            37:   /**********************************************************************
        !            38:   ** Elements above are public.  All that follows is private to pcache.c
        !            39:   ** and should not be accessed by other modules.
        !            40:   */
        !            41:   i16 nRef;                      /* Number of users of this page */
        !            42:   PCache *pCache;                /* Cache that owns this page */
        !            43: 
        !            44:   PgHdr *pDirtyNext;             /* Next element in list of dirty pages */
        !            45:   PgHdr *pDirtyPrev;             /* Previous element in list of dirty pages */
        !            46: };
        !            47: 
        !            48: /* Bit values for PgHdr.flags */
        !            49: #define PGHDR_DIRTY             0x002  /* Page has changed */
        !            50: #define PGHDR_NEED_SYNC         0x004  /* Fsync the rollback journal before
        !            51:                                        ** writing this page to the database */
        !            52: #define PGHDR_NEED_READ         0x008  /* Content is unread */
        !            53: #define PGHDR_REUSE_UNLIKELY    0x010  /* A hint that reuse is unlikely */
        !            54: #define PGHDR_DONT_WRITE        0x020  /* Do not write content to disk */
        !            55: 
        !            56: /* Initialize and shutdown the page cache subsystem */
        !            57: int sqlite3PcacheInitialize(void);
        !            58: void sqlite3PcacheShutdown(void);
        !            59: 
        !            60: /* Page cache buffer management:
        !            61: ** These routines implement SQLITE_CONFIG_PAGECACHE.
        !            62: */
        !            63: void sqlite3PCacheBufferSetup(void *, int sz, int n);
        !            64: 
        !            65: /* Create a new pager cache.
        !            66: ** Under memory stress, invoke xStress to try to make pages clean.
        !            67: ** Only clean and unpinned pages can be reclaimed.
        !            68: */
        !            69: void sqlite3PcacheOpen(
        !            70:   int szPage,                    /* Size of every page */
        !            71:   int szExtra,                   /* Extra space associated with each page */
        !            72:   int bPurgeable,                /* True if pages are on backing store */
        !            73:   int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */
        !            74:   void *pStress,                 /* Argument to xStress */
        !            75:   PCache *pToInit                /* Preallocated space for the PCache */
        !            76: );
        !            77: 
        !            78: /* Modify the page-size after the cache has been created. */
        !            79: void sqlite3PcacheSetPageSize(PCache *, int);
        !            80: 
        !            81: /* Return the size in bytes of a PCache object.  Used to preallocate
        !            82: ** storage space.
        !            83: */
        !            84: int sqlite3PcacheSize(void);
        !            85: 
        !            86: /* One release per successful fetch.  Page is pinned until released.
        !            87: ** Reference counted. 
        !            88: */
        !            89: int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**);
        !            90: void sqlite3PcacheRelease(PgHdr*);
        !            91: 
        !            92: void sqlite3PcacheDrop(PgHdr*);         /* Remove page from cache */
        !            93: void sqlite3PcacheMakeDirty(PgHdr*);    /* Make sure page is marked dirty */
        !            94: void sqlite3PcacheMakeClean(PgHdr*);    /* Mark a single page as clean */
        !            95: void sqlite3PcacheCleanAll(PCache*);    /* Mark all dirty list pages as clean */
        !            96: 
        !            97: /* Change a page number.  Used by incr-vacuum. */
        !            98: void sqlite3PcacheMove(PgHdr*, Pgno);
        !            99: 
        !           100: /* Remove all pages with pgno>x.  Reset the cache if x==0 */
        !           101: void sqlite3PcacheTruncate(PCache*, Pgno x);
        !           102: 
        !           103: /* Get a list of all dirty pages in the cache, sorted by page number */
        !           104: PgHdr *sqlite3PcacheDirtyList(PCache*);
        !           105: 
        !           106: /* Reset and close the cache object */
        !           107: void sqlite3PcacheClose(PCache*);
        !           108: 
        !           109: /* Clear flags from pages of the page cache */
        !           110: void sqlite3PcacheClearSyncFlags(PCache *);
        !           111: 
        !           112: /* Discard the contents of the cache */
        !           113: void sqlite3PcacheClear(PCache*);
        !           114: 
        !           115: /* Return the total number of outstanding page references */
        !           116: int sqlite3PcacheRefCount(PCache*);
        !           117: 
        !           118: /* Increment the reference count of an existing page */
        !           119: void sqlite3PcacheRef(PgHdr*);
        !           120: 
        !           121: int sqlite3PcachePageRefcount(PgHdr*);
        !           122: 
        !           123: /* Return the total number of pages stored in the cache */
        !           124: int sqlite3PcachePagecount(PCache*);
        !           125: 
        !           126: #if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG)
        !           127: /* Iterate through all dirty pages currently stored in the cache. This
        !           128: ** interface is only available if SQLITE_CHECK_PAGES is defined when the 
        !           129: ** library is built.
        !           130: */
        !           131: void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *));
        !           132: #endif
        !           133: 
        !           134: /* Set and get the suggested cache-size for the specified pager-cache.
        !           135: **
        !           136: ** If no global maximum is configured, then the system attempts to limit
        !           137: ** the total number of pages cached by purgeable pager-caches to the sum
        !           138: ** of the suggested cache-sizes.
        !           139: */
        !           140: void sqlite3PcacheSetCachesize(PCache *, int);
        !           141: #ifdef SQLITE_TEST
        !           142: int sqlite3PcacheGetCachesize(PCache *);
        !           143: #endif
        !           144: 
        !           145: /* Free up as much memory as possible from the page cache */
        !           146: void sqlite3PcacheShrink(PCache*);
        !           147: 
        !           148: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
        !           149: /* Try to return memory used by the pcache module to the main memory heap */
        !           150: int sqlite3PcacheReleaseMemory(int);
        !           151: #endif
        !           152: 
        !           153: #ifdef SQLITE_TEST
        !           154: void sqlite3PcacheStats(int*,int*,int*,int*);
        !           155: #endif
        !           156: 
        !           157: void sqlite3PCacheSetDefault(void);
        !           158: 
        !           159: #endif /* _PCACHE_H_ */