summaryrefslogtreecommitdiff
path: root/db/mp
diff options
context:
space:
mode:
Diffstat (limited to 'db/mp')
-rw-r--r--db/mp/Design52
-rw-r--r--db/mp/mp_alloc.c118
-rw-r--r--db/mp/mp_bh.c47
-rw-r--r--db/mp/mp_fget.c84
-rw-r--r--db/mp/mp_fmethod.c22
-rw-r--r--db/mp/mp_fopen.c291
-rw-r--r--db/mp/mp_fput.c120
-rw-r--r--db/mp/mp_fset.c105
-rw-r--r--db/mp/mp_method.c243
-rw-r--r--db/mp/mp_mvcc.c63
-rw-r--r--db/mp/mp_region.c308
-rw-r--r--db/mp/mp_register.c5
-rw-r--r--db/mp/mp_resize.c559
-rw-r--r--db/mp/mp_stat.c35
-rw-r--r--db/mp/mp_sync.c327
-rw-r--r--db/mp/mp_trickle.c19
16 files changed, 1592 insertions, 806 deletions
diff --git a/db/mp/Design b/db/mp/Design
deleted file mode 100644
index 1b26aae6c..000000000
--- a/db/mp/Design
+++ /dev/null
@@ -1,52 +0,0 @@
-$Id: Design,v 11.2 1999/11/21 23:08:27 bostic Exp $
-
-There are three ways we do locking in the mpool code:
-
-Locking a handle mutex to provide concurrency for DB_THREAD operations.
-Locking the region mutex to provide mutual exclusion while reading and
- writing structures in the shared region.
-Locking buffer header mutexes during I/O.
-
-The first will not be further described here. We use the shared mpool
-region lock to provide mutual exclusion while reading/modifying all of
-the data structures, including the buffer headers. We use a per-buffer
-header lock to wait on buffer I/O. The order of locking is as follows:
-
-Searching for a buffer:
- Acquire the region lock.
- Find the buffer header.
- Increment the reference count (guarantee the buffer stays).
- While the BH_LOCKED flag is set (I/O is going on) {
- Release the region lock.
- Explicitly yield the processor if it's not the first pass
- through this loop, otherwise, we can simply spin because
- we'll be simply switching between the two locks.
- Request the buffer lock.
- The I/O will complete...
- Acquire the buffer lock.
- Release the buffer lock.
- Acquire the region lock.
- }
- Return the buffer.
-
-Reading/writing a buffer:
- Acquire the region lock.
- Find/create the buffer header.
- If reading, increment the reference count (guarantee the buffer stays).
- Set the BH_LOCKED flag.
- Acquire the buffer lock (guaranteed not to block).
- Release the region lock.
- Do the I/O and/or initialize the buffer contents.
- Release the buffer lock.
- At this point, the buffer lock is available, but the logical
- operation (flagged by BH_LOCKED) is not yet completed. For
- this reason, among others, threads checking the BH_LOCKED flag
- must loop around their test.
- Acquire the region lock.
- Clear the BH_LOCKED flag.
- Release the region lock.
- Return/discard the buffer.
-
-Pointers to DB_MPOOL, MPOOL, DB_MPOOLFILE and MPOOLFILE structures are
-not reacquired when a region lock is reacquired because they couldn't
-have been closed/discarded and because they never move in memory.
diff --git a/db/mp/mp_alloc.c b/db/mp/mp_alloc.c
index 0619d5ccf..c18e62dff 100644
--- a/db/mp/mp_alloc.c
+++ b/db/mp/mp_alloc.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_alloc.c,v 12.20 2006/09/07 15:11:26 mjc Exp $
+ * $Id: mp_alloc.c,v 12.33 2007/06/01 18:32:44 bostic Exp $
*/
#include "db_config.h"
@@ -38,7 +37,6 @@ __memp_alloc(dbmp, infop, mfp, len, offsetp, retp)
MPOOL *c_mp;
MPOOLFILE *bh_mfp;
size_t freed_space;
- db_mutex_t mutex;
u_int32_t buckets, buffers, high_priority, priority;
u_int32_t put_counter, total_buckets;
int aggressive, alloc_freeze, giveup, got_oldest, ret;
@@ -54,7 +52,7 @@ __memp_alloc(dbmp, infop, mfp, len, offsetp, retp)
aggressive = alloc_freeze = giveup = got_oldest = 0;
hp_tmp = NULL;
- c_mp->stat.st_alloc++;
+ STAT(c_mp->stat.st_alloc++);
/*
* If we're allocating a buffer, and the one we're discarding is the
@@ -86,7 +84,7 @@ __memp_alloc(dbmp, infop, mfp, len, offsetp, retp)
* we need in the hopes it will coalesce into a contiguous chunk of the
* right size. In the latter case we branch back here and try again.
*/
-alloc: if ((ret = __db_shalloc(infop, len, 0, &p)) == 0) {
+alloc: if ((ret = __env_alloc(infop, len, &p)) == 0) {
if (mfp != NULL)
c_mp->stat.st_pages++;
MPOOL_REGION_UNLOCK(dbenv, infop);
@@ -106,6 +104,7 @@ found: if (offsetp != NULL)
* We're not holding the region locked here, these statistics
* can't be trusted.
*/
+#ifdef HAVE_STATISTICS
total_buckets += buckets;
if (total_buckets != 0) {
if (total_buckets > c_mp->stat.st_alloc_max_buckets)
@@ -117,6 +116,7 @@ found: if (offsetp != NULL)
c_mp->stat.st_alloc_max_pages = buffers;
c_mp->stat.st_alloc_pages += buffers;
}
+#endif
return (0);
} else if (giveup || c_mp->stat.st_pages == 0) {
MPOOL_REGION_UNLOCK(dbenv, infop);
@@ -153,24 +153,14 @@ found: if (offsetp != NULL)
}
/*
- * Skip empty buckets.
- *
- * We can check for empty buckets before locking as we
- * only care if the pointer is zero or non-zero.
- */
- if (SH_TAILQ_FIRST(&hp->hash_bucket, __bh) == NULL)
- continue;
-
- /*
* The failure mode is when there are too many buffers we can't
- * write or there's not enough memory in the system. We don't
- * have a way to know that allocation has no way to succeed.
- * We fail if there were no pages returned to the cache after
- * we've been trying for a relatively long time.
+ * write or there's not enough memory in the system to support
+ * the number of pinned buffers.
*
- * Get aggressive if we've tried to flush the number of hash
- * buckets as are in the system and have not found any more
- * space. Aggressive means:
+ * Get aggressive if we've reviewed the entire cache without
+ * freeing 3 times the needed space. (The code resets the
+ * counter when we free 3 times the needed space.) Aggressive
+ * means:
*
* a: set a flag to attempt to flush high priority buffers as
* well as other buffers.
@@ -187,11 +177,15 @@ found: if (offsetp != NULL)
* Always try to allocate memory too, in case some other thread
* returns its memory to the region.
*
+ * We don't have any way to know an allocation has no way to
+ * succeed. Fail if no pages are returned to the cache after
+ * we've been trying for a relatively long time.
+ *
* !!!
* This test ignores pathological cases like no buffers in the
- * system -- that shouldn't be possible.
+ * system -- we check for that early on, so it isn't possible.
*/
- if ((++buckets % c_mp->htab_buckets) == 0) {
+ if (buckets++ == c_mp->htab_buckets) {
if (freed_space > 0)
goto alloc;
MPOOL_REGION_UNLOCK(dbenv, infop);
@@ -207,7 +201,7 @@ found: if (offsetp != NULL)
case 5:
case 6:
(void)__memp_sync_int(
- dbenv, NULL, 0, DB_SYNC_ALLOC, NULL);
+ dbenv, NULL, 0, DB_SYNC_ALLOC, NULL, NULL);
__os_sleep(dbenv, 1, 0);
break;
@@ -222,11 +216,35 @@ found: if (offsetp != NULL)
goto alloc;
}
+ /*
+ * Skip empty buckets.
+ *
+ * We can check for empty buckets before locking as we
+ * only care if the pointer is zero or non-zero.
+ */
+ if (SH_TAILQ_FIRST(&hp->hash_bucket, __bh) == NULL)
+ continue;
+ /*
+ * Skip buckets that only have pinned pages.
+ *
+ * Again we are doing this without locking. If we misread
+ * the number we might improperly skip a bucket but this is
+ * not fatal.
+ */
+ if (hp->hash_priority == UINT32_MAX)
+ continue;
+
if (!aggressive) {
- /* Skip high priority buckets. */
- if (hp->hash_priority > high_priority)
+ /* Adjust if the bucket has not been reset. */
+ priority = hp->hash_priority;
+ if (c_mp->lru_reset != 0 &&
+ c_mp->lru_reset <= hp - dbht)
+ priority -= MPOOL_BASE_DECREMENT;
+ /*
+ * Skip high priority buckets.
+ */
+ if (priority > high_priority)
continue;
-
/*
* Find two buckets and select the one with the lowest
* priority. Performance testing shows that looking
@@ -237,18 +255,22 @@ found: if (offsetp != NULL)
hp_tmp = hp;
continue;
}
- if (hp->hash_priority > hp_tmp->hash_priority)
+ if (c_mp->lru_reset &&
+ c_mp->lru_reset <= hp_tmp - dbht) {
+ if (priority > hp_tmp->hash_priority -
+ MPOOL_BASE_DECREMENT)
+ hp = hp_tmp;
+ } else if (priority > hp_tmp->hash_priority)
hp = hp_tmp;
hp_tmp = NULL;
}
- /* Remember the priority of the buffer we're looking for. */
- priority = hp->hash_priority;
-
/* Unlock the region and lock the hash bucket. */
MPOOL_REGION_UNLOCK(dbenv, infop);
- mutex = hp->mtx_hash;
- MUTEX_LOCK(dbenv, mutex);
+ MUTEX_LOCK(dbenv, hp->mtx_hash);
+
+ /* Remember the priority of the buffer we're looking for. */
+ priority = hp->hash_priority;
#ifdef DIAGNOSTIC
__memp_check_order(dbenv, hp);
@@ -311,10 +333,15 @@ this_hb: if ((bhp = SH_TAILQ_FIRST(&hp->hash_bucket, __bh)) == NULL)
++bhp->ref;
ret = __memp_bhwrite(dbmp, hp, bh_mfp, bhp, 0);
--bhp->ref;
+#ifdef HAVE_STATISTICS
if (ret == 0)
++c_mp->stat.st_rw_evict;
- } else
+#endif
+ }
+#ifdef HAVE_STATISTICS
+ else
++c_mp->stat.st_ro_evict;
+#endif
/*
* Freeze this buffer, if necessary. That is, if the buffer
@@ -373,13 +400,13 @@ this_hb: if ((bhp = SH_TAILQ_FIRST(&hp->hash_bucket, __bh)) == NULL)
++bhp->ref;
if ((ret = __memp_bh_thaw(dbmp, infop, hp,
bhp, NULL)) != 0) {
- MUTEX_UNLOCK(dbenv, mutex);
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
return (ret);
}
alloc_freeze = 0;
goto this_hb;
} else if (alloc_freeze) {
- if ((ret = __memp_bhfree(dbmp, hp, bhp, 0)) != 0)
+ if ((ret = __memp_bhfree(dbmp, infop, hp, bhp, 0)) != 0)
return (ret);
MVCC_MPROTECT(bhp->buf, bh_mfp->stat.st_pagesize,
PROT_READ | PROT_WRITE | PROT_EXEC);
@@ -399,13 +426,13 @@ this_hb: if ((bhp = SH_TAILQ_FIRST(&hp->hash_bucket, __bh)) == NULL)
continue;
} else if (mfp != NULL &&
mfp->stat.st_pagesize == bh_mfp->stat.st_pagesize) {
- if ((ret = __memp_bhfree(dbmp, hp, bhp, 0)) != 0)
+ if ((ret = __memp_bhfree(dbmp, infop, hp, bhp, 0)) != 0)
return (ret);
p = bhp;
goto found;
} else {
- freed_space += __db_shalloc_sizeof(bhp);
- if ((ret = __memp_bhfree(dbmp,
+ freed_space += sizeof(*bhp) + bh_mfp->stat.st_pagesize;
+ if ((ret = __memp_bhfree(dbmp, infop,
hp, bhp, BH_FREE_FREEMEM)) != 0)
return (ret);
}
@@ -419,7 +446,7 @@ this_hb: if ((bhp = SH_TAILQ_FIRST(&hp->hash_bucket, __bh)) == NULL)
* hash bucket lock has already been discarded.
*/
if (0) {
-next_hb: MUTEX_UNLOCK(dbenv, mutex);
+next_hb: MUTEX_UNLOCK(dbenv, hp->mtx_hash);
}
MPOOL_REGION_LOCK(dbenv, infop);
@@ -449,7 +476,7 @@ __memp_free(infop, mfp, buf)
{
MVCC_BHUNALIGN(mfp, buf);
COMPQUIET(mfp, NULL);
- __db_shalloc_free(infop, buf);
+ __env_alloc_free(infop, buf);
}
/*
@@ -516,7 +543,9 @@ __memp_check_order(dbenv, hp)
DB_MPOOL_HASH *hp;
{
BH *bhp, *first_bhp, *tbhp;
- u_int32_t priority, last_priority;
+ u_int32_t dirty, priority, last_priority;
+
+ dirty = 0;
/*
* Assumes the hash bucket is locked.
@@ -526,6 +555,8 @@ __memp_check_order(dbenv, hp)
bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, hq, __bh)) {
DB_ASSERT(dbenv, !SH_CHAIN_HASNEXT(bhp, vc));
+ if (F_ISSET(bhp, BH_DIRTY))
+ dirty++;
priority = BH_PRIORITY(bhp);
DB_ASSERT(dbenv, (bhp == first_bhp) ?
priority == last_priority : priority >= last_priority);
@@ -547,5 +578,6 @@ __memp_check_order(dbenv, hp)
DB_ASSERT(dbenv, bhp->pgno != tbhp->pgno ||
bhp->mf_offset != tbhp->mf_offset);
}
+ DB_ASSERT(dbenv, dirty == hp->hash_page_dirty);
}
#endif
diff --git a/db/mp/mp_bh.c b/db/mp/mp_bh.c
index ef4d1d4be..85cc30cc7 100644
--- a/db/mp/mp_bh.c
+++ b/db/mp/mp_bh.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_bh.c,v 12.31 2006/09/07 19:11:46 bostic Exp $
+ * $Id: mp_bh.c,v 12.38 2007/05/17 15:15:45 bostic Exp $
*/
#include "db_config.h"
@@ -256,9 +255,13 @@ __memp_pgread(dbmfp, hp, bhp, can_create)
if (len < pagesize)
memset(bhp->buf + len, CLEAR_BYTE, pagesize - len);
#endif
+#ifdef HAVE_STATISTICS
++mfp->stat.st_page_create;
} else
++mfp->stat.st_page_in;
+#else
+ }
+#endif
/* Call any pgin function. */
ret = mfp->ftype == 0 ? 0 : __memp_pg(dbmfp, bhp, 1);
@@ -304,18 +307,16 @@ __memp_pgwrite(dbenv, dbmfp, hp, bhp)
mfp = dbmfp == NULL ? NULL : dbmfp->mfp;
callpgin = ret = 0;
- /*
- * We should never be called with a clean or trash buffer.
- * The sync code does call us with already locked buffers.
- */
+ /* We should never be called with a clean or trash buffer. */
DB_ASSERT(dbenv, F_ISSET(bhp, BH_DIRTY));
DB_ASSERT(dbenv, !F_ISSET(bhp, BH_TRASH));
- /* If not already done, lock the buffer and unlock the hash bucket. */
- if (!F_ISSET(bhp, BH_LOCKED)) {
- F_SET(bhp, BH_LOCKED);
- MUTEX_UNLOCK(dbenv, hp->mtx_hash);
- }
+ /*
+ * The sync code has already locked the buffer, but the allocation
+ * code has not. Lock the buffer and release the hash bucket mutex.
+ */
+ F_SET(bhp, BH_LOCKED);
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
/*
* It's possible that the underlying file doesn't exist, either
@@ -333,7 +334,7 @@ __memp_pgwrite(dbenv, dbmfp, hp, bhp)
* If the page is in a file for which we have LSN information, we have
* to ensure the appropriate log records are on disk.
*/
- if (LOGGING_ON(dbenv) && mfp->lsn_off != -1 &&
+ if (LOGGING_ON(dbenv) && mfp->lsn_off != DB_LSN_OFF_NOTSET &&
!IS_CLIENT_PGRECOVER(dbenv)) {
memcpy(&lsn, bhp->buf + mfp->lsn_off, sizeof(DB_LSN));
if (!IS_NOT_LOGGED_LSN(lsn) &&
@@ -402,7 +403,7 @@ __memp_pgwrite(dbenv, dbmfp, hp, bhp)
__memp_fn(dbmfp), (u_long)bhp->pgno);
goto err;
}
- ++mfp->stat.st_page_out;
+ STAT(++mfp->stat.st_page_out);
if (bhp->pgno > mfp->last_flushed_pgno) {
MUTEX_LOCK(dbenv, mfp->mutex);
if (bhp->pgno > mfp->last_flushed_pgno)
@@ -517,20 +518,20 @@ err: __db_errx(dbenv, "%s: %s failed for page %lu",
* Free a bucket header and its referenced data.
*
* PUBLIC: int __memp_bhfree
- * PUBLIC: __P((DB_MPOOL *, DB_MPOOL_HASH *, BH *, u_int32_t));
+ * PUBLIC: __P((DB_MPOOL *, REGINFO *, DB_MPOOL_HASH *, BH *, u_int32_t));
*/
int
-__memp_bhfree(dbmp, hp, bhp, flags)
+__memp_bhfree(dbmp, infop, hp, bhp, flags)
DB_MPOOL *dbmp;
+ REGINFO *infop;
DB_MPOOL_HASH *hp;
BH *bhp;
u_int32_t flags;
{
DB_ENV *dbenv;
- MPOOL *c_mp, *mp;
+ MPOOL *c_mp;
MPOOLFILE *mfp;
BH *next_bhp, *prev_bhp;
- u_int32_t n_cache;
int reorder, ret, t_ret;
#ifdef DIAG_MVCC
size_t pagesize;
@@ -542,8 +543,6 @@ __memp_bhfree(dbmp, hp, bhp, flags)
* Assumes the hash bucket is locked and the MPOOL is not.
*/
dbenv = dbmp->dbenv;
- mp = dbmp->reginfo[0].primary;
- n_cache = NCACHE(mp, bhp->mf_offset, bhp->pgno);
mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset);
#ifdef DIAG_MVCC
pagesize = mfp->stat.st_pagesize;
@@ -623,13 +622,13 @@ __memp_bhfree(dbmp, hp, bhp, flags)
* real.
*/
if (LF_ISSET(BH_FREE_FREEMEM)) {
- MPOOL_REGION_LOCK(dbenv, &dbmp->reginfo[n_cache]);
+ MPOOL_REGION_LOCK(dbenv, infop);
- __memp_free(&dbmp->reginfo[n_cache], mfp, bhp);
- c_mp = dbmp->reginfo[n_cache].primary;
+ __memp_free(infop, mfp, bhp);
+ c_mp = infop->primary;
c_mp->stat.st_pages--;
- MPOOL_REGION_UNLOCK(dbenv, &dbmp->reginfo[n_cache]);
+ MPOOL_REGION_UNLOCK(dbenv, infop);
}
/*
diff --git a/db/mp/mp_fget.c b/db/mp/mp_fget.c
index 5f7eb6802..bb73a0a08 100644
--- a/db/mp/mp_fget.c
+++ b/db/mp/mp_fget.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_fget.c,v 12.33 2006/09/13 14:53:42 mjc Exp $
+ * $Id: mp_fget.c,v 12.43 2007/06/05 11:55:28 mjc Exp $
*/
#include "db_config.h"
@@ -108,36 +107,34 @@ __memp_fget(dbmfp, pgnoaddr, txn, flags, addrp)
enum { FIRST_FOUND, FIRST_MISS, SECOND_FOUND, SECOND_MISS } state;
BH *alloc_bhp, *bhp, *current_bhp, *frozen_bhp, *oldest_bhp;
DB_ENV *dbenv;
+ DB_LSN *read_lsnp;
DB_MPOOL *dbmp;
DB_MPOOL_HASH *hp;
- MPOOL *c_mp, *mp;
+ MPOOL *c_mp;
MPOOLFILE *mfp;
- REGINFO *infop;
+ REGINFO *infop, *t_infop;
TXN_DETAIL *td;
- DB_LSN *read_lsnp;
roff_t mf_offset;
- u_int32_t n_cache, st_hsearch;
+ u_int32_t st_hsearch;
int b_incr, b_locked, dirty, edit, extending, first;
int makecopy, mvcc, need_free, reorder, ret;
*(void **)addrp = NULL;
+ COMPQUIET(c_mp, NULL);
+ COMPQUIET(infop, NULL);
COMPQUIET(oldest_bhp, NULL);
dbenv = dbmfp->dbenv;
dbmp = dbenv->mp_handle;
- c_mp = NULL;
- mp = dbmp->reginfo[0].primary;
mfp = dbmfp->mfp;
mvcc = mfp->multiversion;
mf_offset = R_OFFSET(dbmp->reginfo, mfp);
alloc_bhp = bhp = frozen_bhp = NULL;
read_lsnp = NULL;
+ td = NULL;
hp = NULL;
b_incr = b_locked = extending = makecopy = ret = 0;
- n_cache = 0;
- infop = NULL;
- td = NULL;
if (LF_ISSET(DB_MPOOL_DIRTY)) {
if (F_ISSET(dbmfp, MP_READONLY)) {
@@ -224,25 +221,22 @@ __memp_fget(dbmfp, pgnoaddr, txn, flags, addrp)
F_ISSET(mfp, MP_CAN_MMAP) && *pgnoaddr <= mfp->orig_last_pgno) {
*(void **)addrp = (u_int8_t *)dbmfp->addr +
(*pgnoaddr * mfp->stat.st_pagesize);
- ++mfp->stat.st_map;
+ STAT(++mfp->stat.st_map);
return (0);
}
-hb_search:
- /*
+retry: /*
* Determine the cache and hash bucket where this page lives and get
* local pointers to them. Reset on each pass through this code, the
* page number can change.
*/
- n_cache = NCACHE(mp, mf_offset, *pgnoaddr);
- infop = &dbmp->reginfo[n_cache];
+ MP_GET_BUCKET(dbmfp, *pgnoaddr, &infop, hp, ret);
+ if (ret != 0)
+ return (ret);
c_mp = infop->primary;
- hp = R_ADDR(infop, c_mp->htab);
- hp = &hp[NBUCKET(c_mp, mf_offset, *pgnoaddr)];
/* Search the hash chain for the page. */
-retry: st_hsearch = 0;
- MUTEX_LOCK(dbenv, hp->mtx_hash);
+ st_hsearch = 0;
b_locked = 1;
SH_TAILQ_FOREACH(bhp, &hp->hash_bucket, hq, __bh) {
++st_hsearch;
@@ -326,7 +320,7 @@ retry: st_hsearch = 0;
F_SET(hp, IO_WAITER);
MUTEX_LOCK(dbenv, hp->mtx_io);
}
- ++hp->hash_io_wait;
+ STAT(++hp->hash_io_wait);
/* Release the hash bucket lock. */
MUTEX_UNLOCK(dbenv, hp->mtx_hash);
@@ -362,10 +356,13 @@ thawed: need_free = (--frozen_bhp->ref == 0);
goto retry;
}
+#ifdef HAVE_STATISTICS
++mfp->stat.st_cache_hit;
+#endif
break;
}
+#ifdef HAVE_STATISTICS
/*
* Update the hash bucket search statistics -- do now because our next
* search may be for a different bucket.
@@ -374,6 +371,7 @@ thawed: need_free = (--frozen_bhp->ref == 0);
if (st_hsearch > c_mp->stat.st_hash_longest)
c_mp->stat.st_hash_longest = st_hsearch;
c_mp->stat.st_hash_examined += st_hsearch;
+#endif
/*
* There are 4 possible paths to this location:
@@ -411,6 +409,10 @@ thawed: need_free = (--frozen_bhp->ref == 0);
*/
if (flags == DB_MPOOL_FREE) {
if (--bhp->ref == 0) {
+ if (F_ISSET(bhp, BH_DIRTY)) {
+ --hp->hash_page_dirty;
+ F_CLR(bhp, BH_DIRTY | BH_DIRTY_CREATE);
+ }
/*
* In a multiversion database, this page could
* be requested again so we have to leave it in
@@ -424,17 +426,12 @@ thawed: need_free = (--frozen_bhp->ref == 0);
if (mvcc && (!SH_CHAIN_SINGLETON(bhp, vc) ||
bhp->td_off == INVALID_ROFF ||
!IS_MAX_LSN(*VISIBLE_LSN(dbenv, bhp)))) {
- if (F_ISSET(bhp, BH_DIRTY)) {
- --hp->hash_page_dirty;
- F_CLR(bhp,
- BH_DIRTY | BH_DIRTY_CREATE);
- }
F_SET(bhp, BH_FREED);
MUTEX_UNLOCK(dbenv, hp->mtx_hash);
return (0);
}
return (__memp_bhfree(
- dbmp, hp, bhp, BH_FREE_FREEMEM));
+ dbmp, infop, hp, bhp, BH_FREE_FREEMEM));
}
__db_errx(dbenv,
"File %s: freeing pinned buffer for page %lu",
@@ -447,12 +444,10 @@ thawed: need_free = (--frozen_bhp->ref == 0);
if (flags == DB_MPOOL_CREATE &&
F_ISSET(bhp, BH_FREED)) {
extending = makecopy = 1;
- MUTEX_UNLOCK(dbenv, hp->mtx_hash);
MUTEX_LOCK(dbenv, mfp->mutex);
if (*pgnoaddr > mfp->last_pgno)
mfp->last_pgno = *pgnoaddr;
MUTEX_UNLOCK(dbenv, mfp->mutex);
- MUTEX_LOCK(dbenv, hp->mtx_hash);
}
/*
@@ -478,8 +473,9 @@ thawed: need_free = (--frozen_bhp->ref == 0);
((ret = __txn_oldest_reader(dbenv,
&hp->old_reader)) == 0 &&
BH_OBSOLETE(oldest_bhp, hp->old_reader)))) {
- if ((ret = __memp_bhfree(dbmp, hp,
- oldest_bhp, BH_FREE_REUSE)) != 0)
+ if ((ret = __memp_bhfree(dbmp,
+ infop, hp, oldest_bhp,
+ BH_FREE_REUSE)) != 0)
goto err;
alloc_bhp = oldest_bhp;
} else if (ret != 0)
@@ -547,17 +543,17 @@ alloc: /*
/*
* !!!
- * In the DB_MPOOL_NEW code path, mf_offset and n_cache have
+ * In the DB_MPOOL_NEW code path, infop and c_mp have
* not yet been initialized.
*/
- mf_offset = R_OFFSET(dbmp->reginfo, mfp);
- n_cache = NCACHE(mp, mf_offset, *pgnoaddr);
- infop = &dbmp->reginfo[n_cache];
+ MP_GET_REGION(dbmfp, *pgnoaddr, &infop, ret);
+ if (ret != 0)
+ goto err;
c_mp = infop->primary;
/* Allocate a new buffer header and data space. */
if ((ret =
- __memp_alloc(dbmp,infop, mfp, 0, NULL, &alloc_bhp)) != 0)
+ __memp_alloc(dbmp, infop, mfp, 0, NULL, &alloc_bhp)) != 0)
goto err;
#ifdef DIAGNOSTIC
if ((uintptr_t)alloc_bhp->buf & (sizeof(size_t) - 1)) {
@@ -601,7 +597,10 @@ alloc: /*
*/
if (flags == DB_MPOOL_NEW && *pgnoaddr != mfp->last_pgno + 1) {
*pgnoaddr = mfp->last_pgno + 1;
- if (n_cache != NCACHE(mp, mf_offset, *pgnoaddr)) {
+ MP_GET_REGION(dbmfp, *pgnoaddr, &t_infop,ret);
+ if (ret != 0)
+ goto err;
+ if (t_infop != infop) {
/*
* flags == DB_MPOOL_NEW, so extending is set
* and we're holding the mfp locked.
@@ -641,7 +640,7 @@ alloc: /*
b_locked = 1;
break;
}
- goto hb_search;
+ goto retry;
case SECOND_FOUND:
/*
* We allocated buffer space for the requested page, but then
@@ -764,10 +763,10 @@ alloc: /*
if (flags == DB_MPOOL_CREATE && mfp->ftype != 0)
F_SET(bhp, BH_CALLPGIN);
- ++mfp->stat.st_page_create;
+ STAT(++mfp->stat.st_page_create);
} else {
F_SET(bhp, BH_TRASH);
- ++mfp->stat.st_cache_miss;
+ STAT(++mfp->stat.st_cache_miss);
}
/* Increment buffer count referenced by MPOOLFILE. */
@@ -961,7 +960,8 @@ err: /*
if (frozen_bhp != NULL)
--frozen_bhp;
if (b_incr && --bhp->ref == 0) {
- (void)__memp_bhfree(dbmp, hp, bhp, BH_FREE_FREEMEM);
+ (void)__memp_bhfree(dbmp,
+ infop, hp, bhp, BH_FREE_FREEMEM);
b_locked = 0;
}
}
diff --git a/db/mp/mp_fmethod.c b/db/mp/mp_fmethod.c
index 76d160ee5..38cd11d34 100644
--- a/db/mp/mp_fmethod.c
+++ b/db/mp/mp_fmethod.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_fmethod.c,v 12.13 2006/08/24 14:46:14 bostic Exp $
+ * $Id: mp_fmethod.c,v 12.19 2007/06/01 16:30:30 bostic Exp $
*/
#include "db_config.h"
@@ -67,7 +66,7 @@ __memp_fcreate(dbenv, retp)
return (ret);
dbmfp->ref = 1;
- dbmfp->lsn_offset = -1;
+ dbmfp->lsn_offset = DB_LSN_OFF_NOTSET;
dbmfp->dbenv = dbenv;
dbmfp->mfp = INVALID_ROFF;
@@ -77,13 +76,13 @@ __memp_fcreate(dbenv, retp)
dbmfp->get_fileid = __memp_get_fileid;
dbmfp->get_flags = __memp_get_flags;
dbmfp->get_ftype = __memp_get_ftype;
+ dbmfp->get_last_pgno = __memp_get_last_pgno;
dbmfp->get_lsn_offset = __memp_get_lsn_offset;
dbmfp->get_maxsize = __memp_get_maxsize;
dbmfp->get_pgcookie = __memp_get_pgcookie;
dbmfp->get_priority = __memp_get_priority;
dbmfp->open = __memp_fopen_pp;
dbmfp->put = __memp_fput_pp;
- dbmfp->set = __memp_fset_pp;
dbmfp->set_clear_len = __memp_set_clear_len;
dbmfp->set_fileid = __memp_set_fileid;
dbmfp->set_flags = __memp_set_flags;
@@ -489,16 +488,17 @@ __memp_set_priority(dbmfp, priority)
}
/*
- * __memp_last_pgno --
+ * __memp_get_last_pgno --
* Return the page number of the last page in the file.
*
* !!!
- * Undocumented interface: DB private.
+ * The method is undocumented, but the handle is exported, users occasionally
+ * ask for it.
*
- * PUBLIC: int __memp_last_pgno __P((DB_MPOOLFILE *, db_pgno_t *));
+ * PUBLIC: int __memp_get_last_pgno __P((DB_MPOOLFILE *, db_pgno_t *));
*/
int
-__memp_last_pgno(dbmfp, pgnoaddr)
+__memp_get_last_pgno(dbmfp, pgnoaddr)
DB_MPOOLFILE *dbmfp;
db_pgno_t *pgnoaddr;
{
@@ -540,8 +540,8 @@ __memp_fns(dbmp, mfp)
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
{
- if (mfp->path_off == 0)
- return ((char *)"temporary");
+ if (mfp == NULL || mfp->path_off == 0)
+ return ((char *)"unknown");
return ((char *)R_ADDR(dbmp->reginfo, mfp->path_off));
}
diff --git a/db/mp/mp_fopen.c b/db/mp/mp_fopen.c
index f13876e75..b41565304 100644
--- a/db/mp/mp_fopen.c
+++ b/db/mp/mp_fopen.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_fopen.c,v 12.34 2006/09/09 13:55:52 bostic Exp $
+ * $Id: mp_fopen.c,v 12.44 2007/05/17 17:18:01 bostic Exp $
*/
#include "db_config.h"
@@ -15,8 +14,10 @@
#include "dbinc/db_page.h"
#include "dbinc/hash.h"
-static int __memp_mfp_alloc __P((DB_MPOOL *,
+static int __memp_mpf_alloc __P((DB_MPOOL *,
DB_MPOOLFILE *, const char *, u_int32_t, u_int32_t, MPOOLFILE **));
+static int __memp_mpf_find __P((DB_ENV *,
+ DB_MPOOLFILE *, DB_MPOOL_HASH *, const char *, u_int32_t, MPOOLFILE **));
/*
* __memp_fopen_pp --
@@ -140,14 +141,51 @@ __memp_fopen(dbmfp, mfp, path, flags, mode, pgsize)
bucket = 0;
hp = R_ADDR(dbmp->reginfo, mp->ftab);
- if (path == NULL && mfp == NULL)
- goto alloc;
+ if (mfp == NULL) {
+ if (path == NULL)
+ goto alloc;
- /*
- * Our caller may be able to tell us which underlying MPOOLFILE we
- * need a handle for.
- */
- if (mfp != NULL) {
+ /*
+ * Hash to the proper file table entry and walk it.
+ *
+ * The fileID is a filesystem unique number (e.g., a
+ * UNIX dev/inode pair) plus a timestamp. If files are
+ * removed and created in less than a second, the fileID
+ * can be repeated. The problem with repetition happens
+ * when the file that previously had the fileID value still
+ * has pages in the pool, since we don't want to use them
+ * to satisfy requests for the new file. Because the
+ * DB_TRUNCATE flag reuses the dev/inode pair, repeated
+ * opens with that flag set guarantees matching fileIDs
+ * when the machine can open a file and then re-open
+ * with truncate within a second. For this reason, we
+ * pass that flag down, and, if we find a matching entry,
+ * we ensure that it's never found again, and we create
+ * a new entry for the current request.
+ */
+
+ if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE))
+ bucket = FNBUCKET(path, strlen(path));
+ else
+ bucket = FNBUCKET(dbmfp->fileid, DB_FILE_ID_LEN);
+ hp += bucket;
+
+ /*
+ * If we are passed a FILEID find the MPOOLFILE and inc
+ * its ref count. That way it cannot go away while we
+ * open it.
+ */
+ if (F_ISSET(dbmfp, MP_FILEID_SET)) {
+ MUTEX_LOCK(dbenv, hp->mtx_hash);
+ ret =
+ __memp_mpf_find(dbenv, dbmfp, hp, path, flags,&mfp);
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
+ if (ret != 0)
+ goto err;
+ if (mfp != NULL)
+ refinc = 1;
+ }
+ } else {
/*
* Deadfile can only be set if mpf_cnt goes to zero (or if we
* failed creating the file DB_AM_DISCARD). Increment the ref
@@ -213,7 +251,7 @@ __memp_fopen(dbmfp, mfp, path, flags, mode, pgsize)
}
if ((ret = __db_appname(dbenv,
DB_APP_DATA, path, 0, NULL, &rpath)) == 0)
- ret = __os_open_extend(dbenv, rpath,
+ ret = __os_open(dbenv, rpath,
(u_int32_t)pagesize, oflags, mode, &dbmfp->fhp);
if (mfp != NULL)
MPOOL_SYSTEM_UNLOCK(dbenv);
@@ -289,83 +327,21 @@ __memp_fopen(dbmfp, mfp, path, flags, mode, pgsize)
goto have_mfp;
/*
- * Hash to the proper file table entry and walk it.
- *
- * The fileID is a filesystem unique number (e.g., a UNIX dev/inode
- * pair) plus a timestamp. If files are removed and created in less
- * than a second, the fileID can be repeated. The problem with
- * repetition happens when the file that previously had the fileID
- * value still has pages in the pool, since we don't want to use them
- * to satisfy requests for the new file.
- *
- * Because the DB_TRUNCATE flag reuses the dev/inode pair, repeated
- * opens with that flag set guarantees matching fileIDs when the
- * machine can open a file and then re-open with truncate within a
- * second. For this reason, we pass that flag down, and, if we find
- * a matching entry, we ensure that it's never found again, and we
- * create a new entry for the current request.
- */
- if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE)) {
- DB_ASSERT(dbenv, path != NULL);
- bucket = FNBUCKET(path, strlen(path));
- } else
- bucket = FNBUCKET(dbmfp->fileid, DB_FILE_ID_LEN);
- hp += bucket;
-
- /*
* We can race with another process opening the same file when
* we allocate the mpoolfile structure. We will come back
* here and check the hash table again to see if it has appeared.
* For most files this is not a problem, since the name is locked
* at a higher layer but QUEUE extent files are not locked.
*/
-
check: MUTEX_LOCK(dbenv, hp->mtx_hash);
- SH_TAILQ_FOREACH(mfp, &hp->hash_bucket, q, __mpoolfile) {
- /* Skip dead files and temporary files. */
- if (mfp->deadfile || F_ISSET(mfp, MP_TEMP))
- continue;
-
- /*
- * Any remaining DB_MPOOL_NOFILE databases are in-memory
- * named databases and need only match other in-memory
- * databases with the same name.
- */
- if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE)) {
- if (!mfp->no_backing_file)
- continue;
-
- DB_ASSERT(dbenv, path != NULL);
- if (strcmp(path, R_ADDR(dbmp->reginfo, mfp->path_off)))
- continue;
-
- /*
- * We matched an in-memory file; grab the fileid if
- * it is set in the region, but not in the dbmfp.
- */
- if (!F_ISSET(dbmfp, MP_FILEID_SET))
- (void)__memp_set_fileid(dbmfp,
- R_ADDR(dbmp->reginfo, mfp->fileid_off));
- } else
- if (memcmp(dbmfp->fileid, R_ADDR(dbmp->reginfo,
- mfp->fileid_off), DB_FILE_ID_LEN) != 0)
- continue;
-
- /*
- * If the file is being truncated, remove it from the system
- * and create a new entry.
- *
- * !!!
- * We should be able to set mfp to NULL and break out of the
- * loop, but I like the idea of checking all the entries.
- */
- if (LF_ISSET(DB_TRUNCATE)) {
- MUTEX_LOCK(dbenv, mfp->mutex);
- mfp->deadfile = 1;
- MUTEX_UNLOCK(dbenv, mfp->mutex);
- continue;
- }
+ if ((ret = __memp_mpf_find(dbenv, dbmfp, hp, path, flags, &mfp) != 0))
+ goto err;
+ if (alloc_mfp != NULL && mfp == NULL) {
+ mfp = alloc_mfp;
+ alloc_mfp = NULL;
+ SH_TAILQ_INSERT_HEAD(&hp->hash_bucket, mfp, q, __mpoolfile);
+ } else if (mfp != NULL) {
/*
* Some things about a file cannot be changed: the clear length,
* page size, or LSN location. However, if this is an attempt
@@ -385,7 +361,7 @@ check: MUTEX_LOCK(dbenv, hp->mtx_hash);
mfp->clear_len != DB_CLEARLEN_NOTSET &&
dbmfp->clear_len != mfp->clear_len) ||
(pagesize != 0 && pagesize != mfp->stat.st_pagesize) ||
- (dbmfp->lsn_offset != -1 &&
+ (dbmfp->lsn_offset != DB_LSN_OFF_NOTSET &&
mfp->lsn_off != DB_LSN_OFF_NOTSET &&
dbmfp->lsn_offset != mfp->lsn_off)) {
__db_errx(dbenv,
@@ -395,42 +371,6 @@ check: MUTEX_LOCK(dbenv, hp->mtx_hash);
ret = EINVAL;
goto err;
}
-
- /*
- * Check to see if this file has died while we waited.
- *
- * We normally don't lock the deadfile field when we read it as
- * we only care if the field is zero or non-zero. We do lock
- * on read when searching for a matching MPOOLFILE so that two
- * threads of control don't race between setting the deadfile
- * bit and incrementing the reference count, that is, a thread
- * of control decrementing the reference count and then setting
- * deadfile because the reference count is 0 blocks us finding
- * the file without knowing it's about to be marked dead.
- */
- MUTEX_LOCK(dbenv, mfp->mutex);
- if (mfp->deadfile) {
- MUTEX_UNLOCK(dbenv, mfp->mutex);
- continue;
- }
- ++mfp->mpf_cnt;
- refinc = 1;
- MUTEX_UNLOCK(dbenv, mfp->mutex);
-
- /* Initialize any fields that are not yet set. */
- if (dbmfp->ftype != 0)
- mfp->ftype = dbmfp->ftype;
- if (dbmfp->clear_len != DB_CLEARLEN_NOTSET)
- mfp->clear_len = dbmfp->clear_len;
- if (dbmfp->lsn_offset != -1)
- mfp->lsn_off = dbmfp->lsn_offset;
-
- break;
- }
- if (alloc_mfp != NULL && mfp == NULL) {
- mfp = alloc_mfp;
- alloc_mfp = NULL;
- SH_TAILQ_INSERT_HEAD(&hp->hash_bucket, mfp, q, __mpoolfile);
}
MUTEX_UNLOCK(dbenv, hp->mtx_hash);
@@ -462,7 +402,7 @@ alloc: /*
__os_fileid(dbenv, rpath, 0, dbmfp->fileid)) != 0)
goto err;
- if ((ret = __memp_mfp_alloc(dbmp,
+ if ((ret = __memp_mpf_alloc(dbmp,
dbmfp, path, pagesize, flags, &alloc_mfp)) != 0)
goto err;
@@ -625,8 +565,105 @@ err: if (refinc) {
return (ret);
}
+/*
+ * __memp_mpf_find --
+ * Search a hash bucket for a MPOOLFILE.
+ */
+static int
+__memp_mpf_find(dbenv, dbmfp, hp, path, flags, mfpp)
+ DB_ENV *dbenv;
+ DB_MPOOLFILE *dbmfp;
+ DB_MPOOL_HASH *hp;
+ const char *path;
+ u_int32_t flags;
+ MPOOLFILE **mfpp;
+{
+ DB_MPOOL *dbmp;
+ MPOOLFILE *mfp;
+
+ dbmp = dbenv->mp_handle;
+
+ SH_TAILQ_FOREACH(mfp, &hp->hash_bucket, q, __mpoolfile) {
+ /* Skip dead files and temporary files. */
+ if (mfp->deadfile || F_ISSET(mfp, MP_TEMP))
+ continue;
+
+ /*
+ * Any remaining DB_MPOOL_NOFILE databases are in-memory
+ * named databases and need only match other in-memory
+ * databases with the same name.
+ */
+ if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE)) {
+ if (!mfp->no_backing_file)
+ continue;
+
+ if (strcmp(path, R_ADDR(dbmp->reginfo, mfp->path_off)))
+ continue;
+
+ /*
+ * We matched an in-memory file; grab the fileid if
+ * it is set in the region, but not in the dbmfp.
+ */
+ if (!F_ISSET(dbmfp, MP_FILEID_SET))
+ (void)__memp_set_fileid(dbmfp,
+ R_ADDR(dbmp->reginfo, mfp->fileid_off));
+ } else
+ if (memcmp(dbmfp->fileid, R_ADDR(dbmp->reginfo,
+ mfp->fileid_off), DB_FILE_ID_LEN) != 0)
+ continue;
+
+ /*
+ * If the file is being truncated, remove it from the system
+ * and create a new entry.
+ *
+ * !!!
+ * We should be able to set mfp to NULL and break out of the
+ * loop, but I like the idea of checking all the entries.
+ */
+ if (LF_ISSET(DB_TRUNCATE)) {
+ MUTEX_LOCK(dbenv, mfp->mutex);
+ mfp->deadfile = 1;
+ MUTEX_UNLOCK(dbenv, mfp->mutex);
+ continue;
+ }
+
+ /*
+ * Check to see if this file has died while we waited.
+ *
+ * We normally don't lock the deadfile field when we read it as
+ * we only care if the field is zero or non-zero. We do lock
+ * on read when searching for a matching MPOOLFILE so that two
+ * threads of control don't race between setting the deadfile
+ * bit and incrementing the reference count, that is, a thread
+ * of control decrementing the reference count and then setting
+ * deadfile because the reference count is 0 blocks us finding
+ * the file without knowing it's about to be marked dead.
+ */
+ MUTEX_LOCK(dbenv, mfp->mutex);
+ if (mfp->deadfile) {
+ MUTEX_UNLOCK(dbenv, mfp->mutex);
+ continue;
+ }
+ ++mfp->mpf_cnt;
+ MUTEX_UNLOCK(dbenv, mfp->mutex);
+
+ /* Initialize any fields that are not yet set. */
+ if (dbmfp->ftype != 0)
+ mfp->ftype = dbmfp->ftype;
+ if (dbmfp->clear_len != DB_CLEARLEN_NOTSET)
+ mfp->clear_len = dbmfp->clear_len;
+ if (dbmfp->lsn_offset != -1)
+ mfp->lsn_off = dbmfp->lsn_offset;
+
+ break;
+ }
+
+ *mfpp = mfp;
+ return (0);
+}
+
static int
-__memp_mfp_alloc(dbmp, dbmfp, path, pagesize, flags, retmfp)
+__memp_mpf_alloc(dbmp, dbmfp, path, pagesize, flags, retmfp)
DB_MPOOL *dbmp;
DB_MPOOLFILE *dbmfp;
const char *path;
@@ -742,14 +779,12 @@ __memp_fclose_pp(dbmfp, flags)
/*
* Validate arguments, but as a handle destructor, we can't fail.
- *
- * !!!
- * DB_MPOOL_DISCARD: Undocumented flag: DB private.
*/
- (void)__db_fchk(dbenv, "DB_MPOOLFILE->close", flags, DB_MPOOL_DISCARD);
+ if (flags != 0)
+ (void)__db_ferr(dbenv, "DB_MPOOLFILE->close", 0);
ENV_ENTER(dbenv, ip);
- REPLICATION_WRAP(dbenv, (__memp_fclose(dbmfp, flags)), ret);
+ REPLICATION_WRAP(dbenv, (__memp_fclose(dbmfp, 0)), ret);
ENV_LEAVE(dbenv, ip);
return (ret);
}
@@ -906,7 +941,9 @@ __memp_mf_discard(dbmp, mfp)
{
DB_ENV *dbenv;
DB_MPOOL_HASH *hp;
+#ifdef HAVE_STATISTICS
DB_MPOOL_STAT *sp;
+#endif
MPOOL *mp;
int need_sync, ret, t_ret;
@@ -948,9 +985,10 @@ __memp_mf_discard(dbmp, mfp)
/* Lock the region and collect stats and free the space. */
MPOOL_SYSTEM_LOCK(dbenv);
if (need_sync &&
- (t_ret = __memp_mf_sync(dbmp, mfp, 1)) != 0 && ret == 0)
+ (t_ret = __memp_mf_sync(dbmp, mfp, 0)) != 0 && ret == 0)
ret = t_ret;
+#ifdef HAVE_STATISTICS
/* Copy the statistics into the region. */
sp = &mp->stat;
sp->st_cache_hit += mfp->stat.st_cache_hit;
@@ -959,6 +997,7 @@ __memp_mf_discard(dbmp, mfp)
sp->st_page_create += mfp->stat.st_page_create;
sp->st_page_in += mfp->stat.st_page_in;
sp->st_page_out += mfp->stat.st_page_out;
+#endif
/* Free the space. */
if (mfp->path_off != 0)
diff --git a/db/mp/mp_fput.c b/db/mp/mp_fput.c
index 124d2e1da..53afe8a82 100644
--- a/db/mp/mp_fput.c
+++ b/db/mp/mp_fput.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_fput.c,v 12.22 2006/09/07 20:05:33 bostic Exp $
+ * $Id: mp_fput.c,v 12.36 2007/06/05 11:55:28 mjc Exp $
*/
#include "db_config.h"
@@ -19,12 +18,14 @@ static int __memp_reset_lru __P((DB_ENV *, REGINFO *));
* __memp_fput_pp --
* DB_MPOOLFILE->put pre/post processing.
*
- * PUBLIC: int __memp_fput_pp __P((DB_MPOOLFILE *, void *, u_int32_t));
+ * PUBLIC: int __memp_fput_pp
+ * PUBLIC: __P((DB_MPOOLFILE *, void *, DB_CACHE_PRIORITY, u_int32_t));
*/
int
-__memp_fput_pp(dbmfp, pgaddr, flags)
+__memp_fput_pp(dbmfp, pgaddr, priority, flags)
DB_MPOOLFILE *dbmfp;
void *pgaddr;
+ DB_CACHE_PRIORITY priority;
u_int32_t flags;
{
DB_ENV *dbenv;
@@ -33,10 +34,14 @@ __memp_fput_pp(dbmfp, pgaddr, flags)
dbenv = dbmfp->dbenv;
PANIC_CHECK(dbenv);
+ if (flags != 0)
+ return (__db_ferr(dbenv, "DB_MPOOLFILE->put", 0));
+
+ MPF_ILLEGAL_BEFORE_OPEN(dbmfp, "DB_MPOOLFILE->put");
ENV_ENTER(dbenv, ip);
- ret = __memp_fput(dbmfp, pgaddr, flags);
+ ret = __memp_fput(dbmfp, pgaddr, priority);
if (IS_ENV_REPLICATED(dbenv) &&
(t_ret = __op_rep_exit(dbenv)) != 0 && ret == 0)
ret = t_ret;
@@ -49,47 +54,30 @@ __memp_fput_pp(dbmfp, pgaddr, flags)
* __memp_fput --
* DB_MPOOLFILE->put.
*
- * PUBLIC: int __memp_fput __P((DB_MPOOLFILE *, void *, u_int32_t));
+ * PUBLIC: int __memp_fput __P((DB_MPOOLFILE *, void *, DB_CACHE_PRIORITY));
*/
int
-__memp_fput(dbmfp, pgaddr, flags)
+__memp_fput(dbmfp, pgaddr, priority)
DB_MPOOLFILE *dbmfp;
void *pgaddr;
- u_int32_t flags;
+ DB_CACHE_PRIORITY priority;
{
+ BH *bhp;
DB_ENV *dbenv;
DB_MPOOL *dbmp;
DB_MPOOL_HASH *hp;
MPOOL *c_mp;
MPOOLFILE *mfp;
- BH *bhp;
- u_int32_t n_cache;
- int adjust, ret, t_ret;
+ REGINFO *infop;
+ int adjust, pfactor, ret, t_ret;
dbenv = dbmfp->dbenv;
- MPF_ILLEGAL_BEFORE_OPEN(dbmfp, "DB_MPOOLFILE->put");
dbmp = dbenv->mp_handle;
mfp = dbmfp->mfp;
bhp = (BH *)((u_int8_t *)pgaddr - SSZA(BH, buf));
ret = 0;
/*
- * Check arguments, but don't fail because we want to unpin the page
- * regardless. The problem is when running with replication. There
- * is a reference count we incremented when __memp_fget was called,
- * and we need to unpin the page and decrement that reference count.
- * If we see flag problems, mark the page dirty.
- */
- if (flags) {
- if (__db_fchk(dbenv, "memp_fput", flags,
- DB_MPOOL_DISCARD) != 0) {
- flags = 0;
- ret = EINVAL;
- DB_ASSERT(dbenv, 0);
- }
- }
-
- /*
* If we're mapping the file, there's nothing to do. Because we can
* stop mapping the file at any time, we have to check on each buffer
* to see if the address we gave the application was part of the map
@@ -116,15 +104,10 @@ __memp_fput(dbmfp, pgaddr, flags)
#endif
/* Convert a page address to a buffer header and hash bucket. */
- n_cache = NCACHE(dbmp->reginfo[0].primary, bhp->mf_offset, bhp->pgno);
- c_mp = dbmp->reginfo[n_cache].primary;
- hp = R_ADDR(&dbmp->reginfo[n_cache], c_mp->htab);
- hp = &hp[NBUCKET(c_mp, bhp->mf_offset, bhp->pgno)];
-
- MUTEX_LOCK(dbenv, hp->mtx_hash);
-
- if (LF_ISSET(DB_MPOOL_DISCARD))
- F_SET(bhp, BH_DISCARD);
+ MP_GET_BUCKET(dbmfp, bhp->pgno, &infop, hp, ret);
+ if (ret != 0)
+ return (ret);
+ c_mp = infop->primary;
/*
* Check for a reference count going to zero. This can happen if the
@@ -163,7 +146,8 @@ __memp_fput(dbmfp, pgaddr, flags)
MVCC_MPROTECT(bhp->buf, mfp->stat.st_pagesize, 0);
/* Update priority values. */
- if (F_ISSET(bhp, BH_DISCARD) || mfp->priority == MPOOL_PRI_VERY_LOW)
+ if (priority == DB_PRIORITY_VERY_LOW ||
+ mfp->priority == MPOOL_PRI_VERY_LOW)
bhp->priority = 0;
else {
/*
@@ -173,9 +157,31 @@ __memp_fput(dbmfp, pgaddr, flags)
*/
bhp->priority = c_mp->lru_count;
+ switch (priority) {
+ default:
+ case DB_PRIORITY_UNCHANGED:
+ pfactor = mfp->priority;
+ break;
+ case DB_PRIORITY_VERY_LOW:
+ pfactor = MPOOL_PRI_VERY_LOW;
+ break;
+ case DB_PRIORITY_LOW:
+ pfactor = MPOOL_PRI_LOW;
+ break;
+ case DB_PRIORITY_DEFAULT:
+ pfactor = MPOOL_PRI_DEFAULT;
+ break;
+ case DB_PRIORITY_HIGH:
+ pfactor = MPOOL_PRI_HIGH;
+ break;
+ case DB_PRIORITY_VERY_HIGH:
+ pfactor = MPOOL_PRI_VERY_HIGH;
+ break;
+ }
+
adjust = 0;
- if (mfp->priority != 0)
- adjust = (int)c_mp->stat.st_pages / mfp->priority;
+ if (pfactor != 0)
+ adjust = (int)c_mp->stat.st_pages / pfactor;
if (F_ISSET(bhp, BH_DIRTY))
adjust += (int)c_mp->stat.st_pages / MPOOL_PRI_DIRTY;
@@ -234,10 +240,9 @@ __memp_reset_lru(dbenv, infop)
BH *bhp, *tbhp;
DB_MPOOL_HASH *hp;
MPOOL *c_mp;
- u_int32_t bucket;
+ u_int32_t bucket, priority;
c_mp = infop->primary;
-
/*
* Update the counter so all future allocations will start at the
* bottom.
@@ -253,19 +258,42 @@ __memp_reset_lru(dbenv, infop)
* We can check for empty buckets before locking as we
* only care if the pointer is zero or non-zero.
*/
- if (SH_TAILQ_FIRST(&hp->hash_bucket, __bh) == NULL)
+ if (SH_TAILQ_FIRST(&hp->hash_bucket, __bh) == NULL) {
+ c_mp->lru_reset++;
continue;
+ }
MUTEX_LOCK(dbenv, hp->mtx_hash);
- SH_TAILQ_FOREACH(bhp, &hp->hash_bucket, hq, __bh)
+ c_mp->lru_reset++;
+ /*
+ * We need to take a little care that the bucket does
+ * not become unsorted. This is highly unlikely but
+ * possible.
+ */
+ priority = 0;
+ SH_TAILQ_FOREACH(bhp, &hp->hash_bucket, hq, __bh) {
for (tbhp = bhp; tbhp != NULL;
tbhp = SH_CHAIN_PREV(tbhp, vc, __bh)) {
if (tbhp->priority != UINT32_MAX &&
- tbhp->priority > MPOOL_BASE_DECREMENT)
+ tbhp->priority > MPOOL_BASE_DECREMENT) {
tbhp->priority -= MPOOL_BASE_DECREMENT;
+ if (tbhp->priority < priority)
+ tbhp->priority = priority;
+ }
}
+ priority = bhp->priority;
+ }
+ /*
+ * Reset the hash bucket's priority. The chain is never empty
+ * in this case, so tbhp will never be NULL.
+ */
+ if ((tbhp =
+ SH_TAILQ_FIRST(&hp->hash_bucket, __bh)) != NULL)
+ hp->hash_priority = tbhp->priority;
MUTEX_UNLOCK(dbenv, hp->mtx_hash);
}
+ c_mp->lru_reset = 0;
+ COMPQUIET(dbenv, NULL);
return (0);
}
diff --git a/db/mp/mp_fset.c b/db/mp/mp_fset.c
index e3fd2f4df..46950f4e1 100644
--- a/db/mp/mp_fset.c
+++ b/db/mp/mp_fset.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_fset.c,v 12.16 2006/09/13 14:53:42 mjc Exp $
+ * $Id: mp_fset.c,v 12.23 2007/06/05 11:55:28 mjc Exp $
*/
#include "db_config.h"
@@ -15,108 +14,33 @@
#include "dbinc/txn.h"
/*
- * __memp_fset_pp --
- * DB_MPOOLFILE->set pre/post processing.
- *
- * PUBLIC: int __memp_fset_pp __P((DB_MPOOLFILE *, void *, u_int32_t));
- */
-int
-__memp_fset_pp(dbmfp, pgaddr, flags)
- DB_MPOOLFILE *dbmfp;
- void *pgaddr;
- u_int32_t flags;
-{
- DB_ENV *dbenv;
- DB_THREAD_INFO *ip;
- int ret;
-
- dbenv = dbmfp->dbenv;
-
- PANIC_CHECK(dbenv);
- MPF_ILLEGAL_BEFORE_OPEN(dbmfp, "DB_MPOOLFILE->set");
-
- /* Validate arguments. */
- if (flags == 0)
- return (__db_ferr(dbenv, "memp_fset", 1));
-
- if ((ret = __db_fchk(dbenv, "memp_fset", flags, DB_MPOOL_DISCARD)) != 0)
- return (ret);
-
- ENV_ENTER(dbenv, ip);
- REPLICATION_WRAP(dbenv, (__memp_fset(dbmfp, pgaddr, flags)), ret);
- ENV_LEAVE(dbenv, ip);
- return (ret);
-}
-
-/*
- * __memp_fset --
- * DB_MPOOLFILE->set.
- *
- * PUBLIC: int __memp_fset __P((DB_MPOOLFILE *, void *, u_int32_t));
- */
-int
-__memp_fset(dbmfp, pgaddr, flags)
- DB_MPOOLFILE *dbmfp;
- void *pgaddr;
- u_int32_t flags;
-{
- BH *bhp;
- DB_ENV *dbenv;
- DB_MPOOL *dbmp;
- DB_MPOOL_HASH *hp;
- MPOOL *c_mp;
- u_int32_t n_cache;
-
- dbenv = dbmfp->dbenv;
- dbmp = dbenv->mp_handle;
-
- DB_ASSERT(dbenv, !LF_ISSET(DB_MPOOL_DIRTY));
-
- /* Convert the page address to a buffer header and hash bucket. */
- bhp = (BH *)((u_int8_t *)pgaddr - SSZA(BH, buf));
- n_cache = NCACHE(dbmp->reginfo[0].primary, bhp->mf_offset, bhp->pgno);
- c_mp = dbmp->reginfo[n_cache].primary;
- hp = R_ADDR(&dbmp->reginfo[n_cache], c_mp->htab);
- hp = &hp[NBUCKET(c_mp, bhp->mf_offset, bhp->pgno)];
-
- MUTEX_LOCK(dbenv, hp->mtx_hash);
-
- if (LF_ISSET(DB_MPOOL_DISCARD))
- F_SET(bhp, BH_DISCARD);
-
- MUTEX_UNLOCK(dbenv, hp->mtx_hash);
- return (0);
-}
-
-/*
* __memp_dirty --
* Upgrade a page from a read-only to a writeable pointer.
*
- * PUBLIC: int __memp_dirty __P((DB_MPOOLFILE *, void *, DB_TXN *, u_int32_t));
+ * PUBLIC: int __memp_dirty __P((
+ * PUBLIC: DB_MPOOLFILE *, void *, DB_TXN *, DB_CACHE_PRIORITY, u_int32_t));
*/
int
-__memp_dirty(dbmfp, addrp, txn, flags)
+__memp_dirty(dbmfp, addrp, txn, priority, flags)
DB_MPOOLFILE *dbmfp;
void *addrp;
DB_TXN *txn;
+ DB_CACHE_PRIORITY priority;
u_int32_t flags;
{
BH *bhp;
DB_ENV *dbenv;
- DB_MPOOL *dbmp;
DB_MPOOL_HASH *hp;
DB_TXN *ancestor;
#ifdef DIAG_MVCC
MPOOLFILE *mfp;
#endif
- MPOOL *c_mp;
- u_int32_t n_cache;
+ REGINFO *infop;
int ret;
db_pgno_t pgno;
void *pgaddr;
dbenv = dbmfp->dbenv;
- dbmp = dbenv->mp_handle;
pgaddr = *(void **)addrp;
/* Convert the page address to a buffer header. */
@@ -154,11 +78,11 @@ __memp_dirty(dbmfp, addrp, txn, flags)
(flags == DB_MPOOL_EDIT && *(void **)addrp == pgaddr) ||
(flags != DB_MPOOL_EDIT && *(void **)addrp != pgaddr));
- if ((ret = __memp_fput(dbmfp, pgaddr, 0)) != 0) {
+ if ((ret = __memp_fput(dbmfp, pgaddr, priority)) != 0) {
__db_errx(dbenv,
"%s: error releasing a read-only page",
__memp_fn(dbmfp));
- (void)__memp_fput(dbmfp, *(void **)addrp, 0);
+ (void)__memp_fput(dbmfp, *(void **)addrp, priority);
*(void **)addrp = NULL;
return (ret);
}
@@ -168,13 +92,10 @@ __memp_dirty(dbmfp, addrp, txn, flags)
return (0);
}
- n_cache = NCACHE(dbmp->reginfo[0].primary,
- bhp->mf_offset, bhp->pgno);
- c_mp = dbmp->reginfo[n_cache].primary;
- hp = R_ADDR(&dbmp->reginfo[n_cache], c_mp->htab);
- hp = &hp[NBUCKET(c_mp, bhp->mf_offset, bhp->pgno)];
+ MP_GET_BUCKET(dbmfp, pgno, &infop, hp, ret);
+ if (ret != 0)
+ return (ret);
- MUTEX_LOCK(dbenv, hp->mtx_hash);
/* Set/clear the page bits. */
if (!F_ISSET(bhp, BH_DIRTY)) {
++hp->hash_page_dirty;
@@ -183,7 +104,7 @@ __memp_dirty(dbmfp, addrp, txn, flags)
MUTEX_UNLOCK(dbenv, hp->mtx_hash);
#ifdef DIAG_MVCC
- mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset);
+ mfp = R_ADDR(dbenv->mp_handle->reginfo, bhp->mf_offset);
MVCC_MPROTECT(bhp->buf, mfp->stat.st_pagesize, PROT_READ | PROT_WRITE);
#endif
return (0);
diff --git a/db/mp/mp_method.c b/db/mp/mp_method.c
index 14c144974..e9096827c 100644
--- a/db/mp/mp_method.c
+++ b/db/mp/mp_method.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_method.c,v 12.36 2006/09/15 18:54:13 margo Exp $
+ * $Id: mp_method.c,v 12.50 2007/06/01 18:32:44 bostic Exp $
*/
#include "db_config.h"
@@ -15,13 +14,13 @@
#include "dbinc/hash.h"
/*
- * __memp_dbenv_create --
+ * __memp_env_create --
* Mpool specific creation of the DB_ENV structure.
*
- * PUBLIC: int __memp_dbenv_create __P((DB_ENV *));
+ * PUBLIC: int __memp_env_create __P((DB_ENV *));
*/
int
-__memp_dbenv_create(dbenv)
+__memp_env_create(dbenv)
DB_ENV *dbenv;
{
/*
@@ -37,7 +36,7 @@ __memp_dbenv_create(dbenv)
* Solaris needs 24 and 52 bytes for the same structures. The minimum
* number of hash buckets is 37. These contain a mutex also.
*/
- dbenv->mp_bytes =
+ dbenv->mp_bytes = dbenv->mp_max_bytes =
32 * ((8 * 1024) + sizeof(BH)) + 37 * sizeof(DB_MPOOL_HASH);
dbenv->mp_ncache = 1;
@@ -45,13 +44,13 @@ __memp_dbenv_create(dbenv)
}
/*
- * __memp_dbenv_destroy --
+ * __memp_env_destroy --
* Mpool specific destruction of the DB_ENV structure.
*
- * PUBLIC: void __memp_dbenv_destroy __P((DB_ENV *));
+ * PUBLIC: void __memp_env_destroy __P((DB_ENV *));
*/
void
-__memp_dbenv_destroy(dbenv)
+__memp_env_destroy(dbenv)
DB_ENV *dbenv;
{
COMPQUIET(dbenv, NULL);
@@ -109,8 +108,6 @@ __memp_set_cachesize(dbenv, gbytes, bytes, arg_ncache)
{
u_int ncache;
- ENV_ILLEGAL_AFTER_OPEN(dbenv, "DB_ENV->set_cachesize");
-
/* Normalize the cache count. */
ncache = arg_ncache <= 0 ? 1 : (u_int)arg_ncache;
@@ -133,18 +130,18 @@ __memp_set_cachesize(dbenv, gbytes, bytes, arg_ncache)
* wrapping in the calculation of the number of hash buckets. See
* __memp_open for details.
*/
- if (sizeof(roff_t) <= 4) {
- if (gbytes / ncache >= 4) {
+ if (!F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
+ if (sizeof(roff_t) <= 4 && gbytes / ncache >= 4) {
__db_errx(dbenv,
"individual cache size too large: maximum is 4GB");
return (EINVAL);
}
- } else
if (gbytes / ncache > 10000) {
__db_errx(dbenv,
"individual cache size too large: maximum is 10TB");
return (EINVAL);
}
+ }
/*
* If the application requested less than 500Mb, increase the cachesize
@@ -164,6 +161,9 @@ __memp_set_cachesize(dbenv, gbytes, bytes, arg_ncache)
bytes = ncache * DB_CACHESIZE_MIN;
}
+ if (F_ISSET(dbenv, DB_ENV_OPEN_CALLED))
+ return (__memp_resize(dbenv->mp_handle, gbytes, bytes));
+
dbenv->mp_gbytes = gbytes;
dbenv->mp_bytes = bytes;
dbenv->mp_ncache = ncache;
@@ -172,6 +172,76 @@ __memp_set_cachesize(dbenv, gbytes, bytes, arg_ncache)
}
/*
+ * __memp_set_config --
+ * Set the cache subsystem configuration.
+ *
+ * PUBLIC: int __memp_set_config __P((DB_ENV *, u_int32_t, int));
+ */
+int
+__memp_set_config(dbenv, which, on)
+ DB_ENV *dbenv;
+ u_int32_t which;
+ int on;
+{
+ DB_MPOOL *dbmp;
+ MPOOL *mp;
+
+ ENV_NOT_CONFIGURED(dbenv,
+ dbenv->mp_handle, "DB_ENV->memp_set_config", DB_INIT_MPOOL);
+
+ switch (which) {
+ case DB_MEMP_SUPPRESS_WRITE:
+ case DB_MEMP_SYNC_INTERRUPT:
+ if (MPOOL_ON(dbenv)) {
+ dbmp = dbenv->mp_handle;
+ mp = dbmp->reginfo[0].primary;
+ if (on)
+ FLD_SET(mp->config_flags, which);
+ else
+ FLD_CLR(mp->config_flags, which);
+ }
+ break;
+ default:
+ return (EINVAL);
+ }
+ return (0);
+}
+
+/*
+ * __memp_get_config --
+ * Return the cache subsystem configuration.
+ *
+ * PUBLIC: int __memp_get_config __P((DB_ENV *, u_int32_t, int *));
+ */
+int
+__memp_get_config(dbenv, which, onp)
+ DB_ENV *dbenv;
+ u_int32_t which;
+ int *onp;
+{
+ DB_MPOOL *dbmp;
+ MPOOL *mp;
+
+ ENV_REQUIRES_CONFIG(dbenv,
+ dbenv->mp_handle, "DB_ENV->memp_get_config", DB_INIT_MPOOL);
+
+ switch (which) {
+ case DB_MEMP_SUPPRESS_WRITE:
+ case DB_MEMP_SYNC_INTERRUPT:
+ if (MPOOL_ON(dbenv)) {
+ dbmp = dbenv->mp_handle;
+ mp = dbmp->reginfo[0].primary;
+ *onp = FLD_ISSET(mp->config_flags, which) ? 1 : 0;
+ } else
+ *onp = 0;
+ break;
+ default:
+ return (EINVAL);
+ }
+ return (0);
+}
+
+/*
* PUBLIC: int __memp_get_mp_max_openfd __P((DB_ENV *, int *));
*/
int
@@ -224,12 +294,13 @@ __memp_set_mp_max_openfd(dbenv, maxopenfd)
}
/*
- * PUBLIC: int __memp_get_mp_max_write __P((DB_ENV *, int *, int *));
+ * PUBLIC: int __memp_get_mp_max_write __P((DB_ENV *, int *, db_timeout_t *));
*/
int
__memp_get_mp_max_write(dbenv, maxwritep, maxwrite_sleepp)
DB_ENV *dbenv;
- int *maxwritep, *maxwrite_sleepp;
+ int *maxwritep;
+ db_timeout_t *maxwrite_sleepp;
{
DB_MPOOL *dbmp;
MPOOL *mp;
@@ -255,12 +326,13 @@ __memp_get_mp_max_write(dbenv, maxwritep, maxwrite_sleepp)
* __memp_set_mp_max_write --
* Set the maximum continuous I/O count.
*
- * PUBLIC: int __memp_set_mp_max_write __P((DB_ENV *, int, int));
+ * PUBLIC: int __memp_set_mp_max_write __P((DB_ENV *, int, db_timeout_t));
*/
int
__memp_set_mp_max_write(dbenv, maxwrite, maxwrite_sleep)
DB_ENV *dbenv;
- int maxwrite, maxwrite_sleep;
+ int maxwrite;
+ db_timeout_t maxwrite_sleep;
{
DB_MPOOL *dbmp;
MPOOL *mp;
@@ -366,9 +438,13 @@ __memp_nameop(dbenv, fileid, newname, fullold, fullnew, inmem)
#define op_is_remove (newname == NULL)
COMPQUIET(bucket, 0);
+ COMPQUIET(hp, NULL);
+ COMPQUIET(newname_off, 0);
+ COMPQUIET(nlen, 0);
dbmp = NULL;
mfp = NULL;
+ nhp = NULL;
p = NULL;
locked = ret = 0;
@@ -378,63 +454,61 @@ __memp_nameop(dbenv, fileid, newname, fullold, fullnew, inmem)
dbmp = dbenv->mp_handle;
mp = dbmp->reginfo[0].primary;
hp = R_ADDR(dbmp->reginfo, mp->ftab);
- nhp = NULL;
- /*
- * Remove or rename a file that the mpool might know about. We assume
- * that the fop layer has the file locked for exclusive access, so we
- * don't worry about locking except for the mpool mutexes. Checkpoint
- * can happen at any time, independent of file locking, so we have to
- * do the actual unlink or rename system call to avoid any race.
- *
- * If this is a rename, allocate first, because we can't recursively
- * grab the region lock. If this is a memory file
- * then on a rename, we need to make sure that the new name does
- * not exist.
- */
- hp = R_ADDR(dbmp->reginfo, mp->ftab);
- if (op_is_remove) {
- COMPQUIET(newname_off, INVALID_ROFF);
- } else {
+ if (!op_is_remove) {
nlen = strlen(newname);
if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
NULL, nlen + 1, &newname_off, &p)) != 0)
return (ret);
memcpy(p, newname, nlen + 1);
- MPOOL_SYSTEM_LOCK(dbenv);
- locked = 1;
- if (inmem) {
- bucket = FNBUCKET(newname, nlen);
- nhp = hp + bucket;
- MUTEX_LOCK(dbenv, nhp->mtx_hash);
- SH_TAILQ_FOREACH(mfp, &nhp->hash_bucket, q, __mpoolfile)
- if (!mfp->deadfile &&
- mfp->no_backing_file && strcmp(newname,
- R_ADDR(dbmp->reginfo, mfp->path_off)) == 0)
- break;
- MUTEX_UNLOCK(dbenv, nhp->mtx_hash);
- if (mfp != NULL) {
- ret = EEXIST;
- goto err;
- }
- }
}
- if (locked == 0)
- MPOOL_SYSTEM_LOCK(dbenv);
- locked = 1;
-
+ /*
+ * Remove or rename a file that the mpool might know about. We assume
+ * that the fop layer has the file locked for exclusive access, so we
+ * don't worry about locking except for the mpool mutexes. Checkpoint
+ * can happen at any time, independent of file locking, so we have to
+ * do the actual unlink or rename system call while holding
+ * all affected buckets locked.
+ *
+ * If this is a rename and this is a memory file then we need
+ * to make sure that the new name does not exist. Since we
+ * are locking two buckets lock them in ascending order.
+ */
if (inmem) {
DB_ASSERT(dbenv, fullold != NULL);
hp += FNBUCKET(fullold, strlen(fullold));
+ if (!op_is_remove) {
+ bucket = FNBUCKET(newname, nlen);
+ nhp = R_ADDR(dbmp->reginfo, mp->ftab);
+ nhp += bucket;
+ }
} else
hp += FNBUCKET(fileid, DB_FILE_ID_LEN);
+ if (nhp != NULL && nhp < hp)
+ MUTEX_LOCK(dbenv, nhp->mtx_hash);
+ MUTEX_LOCK(dbenv, hp->mtx_hash);
+ if (nhp != NULL && nhp > hp)
+ MUTEX_LOCK(dbenv, nhp->mtx_hash);
+ locked = 1;
+
+ if (!op_is_remove && inmem) {
+ SH_TAILQ_FOREACH(mfp, &nhp->hash_bucket, q, __mpoolfile)
+ if (!mfp->deadfile &&
+ mfp->no_backing_file && strcmp(newname,
+ R_ADDR(dbmp->reginfo, mfp->path_off)) == 0)
+ break;
+ if (mfp != NULL) {
+ ret = EEXIST;
+ goto err;
+ }
+ }
+
/*
* Find the file -- if mpool doesn't know about this file, that may
- * not be an error -- if the file is not a memory-only file and it
+ * not be an error.
*/
- MUTEX_LOCK(dbenv, hp->mtx_hash);
SH_TAILQ_FOREACH(mfp, &hp->hash_bucket, q, __mpoolfile) {
/* Ignore non-active files. */
if (mfp->deadfile || F_ISSET(mfp, MP_TEMP))
@@ -447,17 +521,21 @@ __memp_nameop(dbenv, fileid, newname, fullold, fullnew, inmem)
break;
}
- MUTEX_UNLOCK(dbenv, hp->mtx_hash);
- if (mfp == NULL)
+
+ if (mfp == NULL) {
+ if (inmem) {
+ ret = ENOENT;
+ goto err;
+ }
goto fsop;
+ }
if (op_is_remove) {
MUTEX_LOCK(dbenv, mfp->mutex);
/*
- * In-memory dbs have an artificially incremented
- * ref count so that they do not ever get reclaimed
- * as long as they exist. Since we are now deleting
- * the database, we need to dec that count.
+ * In-memory dbs have an artificially incremented ref count so
+ * they do not get reclaimed as long as they exist. Since we
+ * are now deleting the database, we need to dec that count.
*/
if (mfp->no_backing_file)
mfp->mpf_cnt--;
@@ -465,31 +543,22 @@ __memp_nameop(dbenv, fileid, newname, fullold, fullnew, inmem)
MUTEX_UNLOCK(dbenv, mfp->mutex);
} else {
/*
- * Else, it's a rename. We've allocated memory
- * for the new name. Swap it with the old one.
+ * Else, it's a rename. We've allocated memory for the new
+ * name. Swap it with the old one. If it's in memory we
+ * need to move it the right bucket.
*/
p = R_ADDR(dbmp->reginfo, mfp->path_off);
mfp->path_off = newname_off;
- /* If its in memory we need to move it the right bucket. */
- if (inmem) {
+ if (inmem && hp != nhp) {
DB_ASSERT(dbenv, nhp != NULL);
- MUTEX_LOCK(dbenv, hp->mtx_hash);
SH_TAILQ_REMOVE(&hp->hash_bucket, mfp, q, __mpoolfile);
- MUTEX_UNLOCK(dbenv, hp->mtx_hash);
mfp->bucket = bucket;
- MUTEX_LOCK(dbenv, nhp->mtx_hash);
SH_TAILQ_INSERT_TAIL(&nhp->hash_bucket, mfp, q);
- MUTEX_UNLOCK(dbenv, nhp->mtx_hash);
}
}
-fsop: if (mfp == NULL && inmem) {
- ret = ENOENT;
- goto err;
- }
-
- /*
+fsop: /*
* If this is a real file, then mfp could be NULL, because
* mpool isn't turned on, and we still need to do the file ops.
*/
@@ -504,12 +573,14 @@ fsop: if (mfp == NULL && inmem) {
ret = 0;
} else {
/*
- * Defensive only, fullname should never be
+ * Defensive only, fullnew should never be
* NULL.
*/
DB_ASSERT(dbenv, fullnew != NULL);
- if (fullnew == NULL)
- return (EINVAL);
+ if (fullnew == NULL) {
+ ret = EINVAL;
+ goto err;
+ }
ret = __os_rename(dbenv, fullold, fullnew, 1);
}
}
@@ -518,8 +589,12 @@ fsop: if (mfp == NULL && inmem) {
err: if (p != NULL)
__memp_free(&dbmp->reginfo[0], NULL, p);
- if (locked == 1)
- MPOOL_SYSTEM_UNLOCK(dbenv);
+ /* If we have buckets locked, unlock them when done moving files. */
+ if (locked == 1) {
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
+ if (nhp != NULL && nhp != hp)
+ MUTEX_UNLOCK(dbenv, nhp->mtx_hash);
+ }
return (ret);
}
diff --git a/db/mp/mp_mvcc.c b/db/mp/mp_mvcc.c
index 4a763e1de..e797df904 100644
--- a/db/mp/mp_mvcc.c
+++ b/db/mp/mp_mvcc.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 2006,2007 Oracle. All rights reserved.
*
- * $Id: mp_mvcc.c,v 12.24 2006/09/18 13:11:50 mjc Exp $
+ * $Id: mp_mvcc.c,v 12.34 2007/06/05 11:55:28 mjc Exp $
*/
#include "db_config.h"
@@ -92,9 +91,12 @@ __memp_bucket_reorder(dbenv, hp, bhp)
next, bhp, hq, __bh);
}
-done: /* Reset the hash bucket's priority. */
- hp->hash_priority =
- BH_PRIORITY(SH_TAILQ_FIRST(&hp->hash_bucket, __bh));
+done: /*
+ * Reset the hash bucket's priority -- the chain is never empty in
+ * this case, so bhp will never be NULL.
+ */
+ if ((bhp = SH_TAILQ_FIRST(&hp->hash_bucket, __bh)) != NULL)
+ hp->hash_priority = BH_PRIORITY(bhp);
}
/*
@@ -103,7 +105,8 @@ done: /* Reset the hash bucket's priority. */
*
* PUBLIC: int __memp_bh_settxn __P((DB_MPOOL *, MPOOLFILE *mfp, BH *, void *));
*/
-int __memp_bh_settxn(dbmp, mfp, bhp, vtd)
+int
+__memp_bh_settxn(dbmp, mfp, bhp, vtd)
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
BH *bhp;
@@ -149,16 +152,13 @@ __memp_skip_curadj(dbc, pgno)
DB_MPOOL_HASH *hp;
DB_MPOOLFILE *dbmfp;
DB_TXN *txn;
- MPOOL *c_mp, *mp;
MPOOLFILE *mfp;
REGINFO *infop;
roff_t mf_offset;
- u_int32_t n_cache;
- int skip;
+ int ret, skip;
dbenv = dbc->dbp->dbenv;
dbmp = dbenv->mp_handle;
- mp = dbmp->reginfo[0].primary;
dbmfp = dbc->dbp->mpf;
mfp = dbmfp->mfp;
mf_offset = R_OFFSET(dbmp->reginfo, mfp);
@@ -172,13 +172,13 @@ __memp_skip_curadj(dbc, pgno)
* local pointers to them. Reset on each pass through this code, the
* page number can change.
*/
- n_cache = NCACHE(mp, mf_offset, pgno);
- infop = &dbmp->reginfo[n_cache];
- c_mp = infop->primary;
- hp = R_ADDR(infop, c_mp->htab);
- hp = &hp[NBUCKET(c_mp, mf_offset, pgno)];
+ MP_GET_BUCKET(dbmfp, pgno, &infop, hp, ret);
+ if (ret != 0) {
+ /* Panic: there is no way to return the error. */
+ (void)__db_panic(dbenv, ret);
+ return (0);
+ }
- MUTEX_LOCK(dbenv, hp->mtx_hash);
SH_TAILQ_FOREACH(bhp, &hp->hash_bucket, hq, __bh) {
if (bhp->pgno != pgno || bhp->mf_offset != mf_offset)
continue;
@@ -251,12 +251,12 @@ __memp_bh_freeze(dbmp, infop, hp, bhp, need_frozenp)
*need_frozenp = 1;
/* There might be a small amount of unallocated space. */
- if (__db_shalloc(infop,
- sizeof(BH_FROZEN_ALLOC) + sizeof(BH_FROZEN_PAGE), 0,
+ if (__env_alloc(infop,
+ sizeof(BH_FROZEN_ALLOC) + sizeof(BH_FROZEN_PAGE),
&frozen_alloc) == 0) {
frozen_bhp = (BH *)(frozen_alloc + 1);
- SH_TAILQ_INSERT_HEAD(&c_mp->alloc_frozen, frozen_alloc,
- links, __bh_frozen_a);
+ SH_TAILQ_INSERT_TAIL(&c_mp->alloc_frozen,
+ frozen_alloc, links);
}
}
MPOOL_REGION_UNLOCK(dbenv, infop);
@@ -285,7 +285,7 @@ __memp_bh_freeze(dbmp, infop, hp, bhp, need_frozenp)
if ((ret = __db_appname(dbenv, DB_APP_NONE, filename,
0, NULL, &real_name)) != 0)
goto err;
- if ((ret = __os_open_extend(dbenv, real_name, pagesize,
+ if ((ret = __os_open(dbenv, real_name, pagesize,
DB_OSO_CREATE | DB_OSO_EXCL, dbenv->db_mode, &fhp)) == 0) {
/* We're creating the file -- initialize the metadata page. */
magic = DB_FREEZER_MAGIC;
@@ -299,8 +299,8 @@ __memp_bh_freeze(dbmp, infop, hp, bhp, need_frozenp)
(ret = __os_seek(dbenv, fhp, 0, 0, 0)) != 0)
goto err;
} else if (ret == EEXIST)
- ret = __os_open_extend(dbenv, real_name, pagesize, 0,
- dbenv->db_mode, &fhp);
+ ret = __os_open(
+ dbenv, real_name, pagesize, 0, dbenv->db_mode, &fhp);
if (ret != 0)
goto err;
if ((ret = __os_read(dbenv, fhp, &magic, sizeof(u_int32_t),
@@ -372,8 +372,11 @@ __memp_bh_freeze(dbmp, infop, hp, bhp, need_frozenp)
* Increment the file's block count -- freeing the original buffer will
* decrement it.
*/
+ MUTEX_LOCK(dbenv, bh_mfp->mutex);
++bh_mfp->block_cnt;
- ++hp->hash_frozen;
+ MUTEX_UNLOCK(dbenv, bh_mfp->mutex);
+
+ STAT(++hp->hash_frozen);
if (0) {
err: if (ret == 0)
@@ -492,8 +495,8 @@ __memp_bh_thaw(dbmp, infop, hp, frozen_bhp, alloc_bhp)
&real_name)) != 0)
goto err;
- if ((ret = __os_open_extend(dbenv, real_name, pagesize, 0,
- dbenv->db_mode, &fhp)) != 0)
+ if ((ret = __os_open(
+ dbenv, real_name, pagesize, 0, dbenv->db_mode, &fhp)) != 0)
goto err;
/*
@@ -625,8 +628,8 @@ __memp_bh_thaw(dbmp, infop, hp, frozen_bhp, alloc_bhp)
if (reorder) {
if (next_bhp != NULL)
__memp_bucket_reorder(dbenv, hp, next_bhp);
- else
- hp->hash_priority = BH_PRIORITY(SH_TAILQ_FIRST(
+ else if (!SH_TAILQ_EMPTY(&hp->hash_bucket))
+ hp->hash_priority = BH_PRIORITY(SH_TAILQ_FIRSTP(
&hp->hash_bucket, __bh));
}
@@ -651,10 +654,12 @@ __memp_bh_thaw(dbmp, infop, hp, frozen_bhp, alloc_bhp)
F_CLR(frozen_bhp, BH_FROZEN | BH_LOCKED);
}
+#ifdef HAVE_STATISTICS
if (alloc_bhp != NULL)
++hp->hash_thawed;
else
++hp->hash_frozen_freed;
+#endif
if (0) {
err: if (ret == 0)
diff --git a/db/mp/mp_region.c b/db/mp/mp_region.c
index a02683f21..34a1ced15 100644
--- a/db/mp/mp_region.c
+++ b/db/mp/mp_region.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_region.c,v 12.21 2006/08/24 14:46:15 bostic Exp $
+ * $Id: mp_region.c,v 12.33 2007/05/17 17:18:01 bostic Exp $
*/
#include "db_config.h"
@@ -12,7 +11,6 @@
#include "db_int.h"
#include "dbinc/mp.h"
-static int __memp_init __P((DB_ENV *, DB_MPOOL *, u_int, u_int32_t));
static int __memp_init_config __P((DB_ENV *, MPOOL *));
static void __memp_region_size __P((DB_ENV *, roff_t *, u_int32_t *));
@@ -20,17 +18,18 @@ static void __memp_region_size __P((DB_ENV *, roff_t *, u_int32_t *));
* __memp_open --
* Internal version of memp_open: only called from DB_ENV->open.
*
- * PUBLIC: int __memp_open __P((DB_ENV *));
+ * PUBLIC: int __memp_open __P((DB_ENV *, int));
*/
int
-__memp_open(dbenv)
+__memp_open(dbenv, create_ok)
DB_ENV *dbenv;
+ int create_ok;
{
DB_MPOOL *dbmp;
MPOOL *mp;
REGINFO reginfo;
roff_t reg_size;
- u_int i;
+ u_int i, max_nreg;
u_int32_t htab_buckets, *regids;
int ret;
@@ -50,9 +49,9 @@ __memp_open(dbenv)
reginfo.type = REGION_TYPE_MPOOL;
reginfo.id = INVALID_REGION_ID;
reginfo.flags = REGION_JOIN_OK;
- if (F_ISSET(dbenv, DB_ENV_CREATE))
+ if (create_ok)
F_SET(&reginfo, REGION_CREATE_OK);
- if ((ret = __db_r_attach(dbenv, &reginfo, reg_size)) != 0)
+ if ((ret = __env_region_attach(dbenv, &reginfo, reg_size)) != 0)
goto err;
/*
@@ -65,17 +64,18 @@ __memp_open(dbenv)
* the REGINFO structures and create them. Make sure we don't
* clear the wrong entries on error.
*/
- dbmp->nreg = dbenv->mp_ncache;
+ max_nreg = __memp_max_regions(dbenv);
if ((ret = __os_calloc(dbenv,
- dbmp->nreg, sizeof(REGINFO), &dbmp->reginfo)) != 0)
+ max_nreg, sizeof(REGINFO), &dbmp->reginfo)) != 0)
goto err;
/* Make sure we don't clear the wrong entries on error. */
- for (i = 0; i < dbmp->nreg; ++i)
- dbmp->reginfo[i].id = INVALID_REGION_ID;
dbmp->reginfo[0] = reginfo;
+ for (i = 1; i < max_nreg; ++i)
+ dbmp->reginfo[i].id = INVALID_REGION_ID;
/* Initialize the first region. */
- if ((ret = __memp_init(dbenv, dbmp, 0, htab_buckets)) != 0)
+ if ((ret = __memp_init(dbenv, dbmp,
+ 0, htab_buckets, max_nreg)) != 0)
goto err;
/*
@@ -84,16 +84,17 @@ __memp_open(dbenv)
*/
mp = R_ADDR(dbmp->reginfo, dbmp->reginfo[0].rp->primary);
regids = R_ADDR(dbmp->reginfo, mp->regids);
- for (i = 1; i < dbmp->nreg; ++i) {
+ regids[0] = dbmp->reginfo[0].id;
+ for (i = 1; i < dbenv->mp_ncache; ++i) {
dbmp->reginfo[i].dbenv = dbenv;
dbmp->reginfo[i].type = REGION_TYPE_MPOOL;
dbmp->reginfo[i].id = INVALID_REGION_ID;
dbmp->reginfo[i].flags = REGION_CREATE_OK;
- if ((ret = __db_r_attach(
+ if ((ret = __env_region_attach(
dbenv, &dbmp->reginfo[i], reg_size)) != 0)
goto err;
- if ((ret =
- __memp_init(dbenv, dbmp, i, htab_buckets)) != 0)
+ if ((ret = __memp_init(dbenv, dbmp,
+ i, htab_buckets, max_nreg)) != 0)
goto err;
regids[i] = dbmp->reginfo[i].id;
@@ -105,30 +106,30 @@ __memp_open(dbenv)
* information.
*/
mp = R_ADDR(&reginfo, reginfo.rp->primary);
- dbmp->nreg = mp->nreg;
+ dbenv->mp_ncache = mp->nreg;
if ((ret = __os_calloc(dbenv,
- dbmp->nreg, sizeof(REGINFO), &dbmp->reginfo)) != 0)
+ mp->max_nreg, sizeof(REGINFO), &dbmp->reginfo)) != 0)
goto err;
/* Make sure we don't clear the wrong entries on error. */
- for (i = 0; i < dbmp->nreg; ++i)
+ for (i = 0; i < dbenv->mp_ncache; ++i)
dbmp->reginfo[i].id = INVALID_REGION_ID;
dbmp->reginfo[0] = reginfo;
/* Join remaining regions. */
regids = R_ADDR(dbmp->reginfo, mp->regids);
- for (i = 1; i < dbmp->nreg; ++i) {
+ for (i = 1; i < dbenv->mp_ncache; ++i) {
dbmp->reginfo[i].dbenv = dbenv;
dbmp->reginfo[i].type = REGION_TYPE_MPOOL;
dbmp->reginfo[i].id = regids[i];
dbmp->reginfo[i].flags = REGION_JOIN_OK;
- if ((ret = __db_r_attach(
+ if ((ret = __env_region_attach(
dbenv, &dbmp->reginfo[i], 0)) != 0)
goto err;
}
}
/* Set the local addresses for the regions. */
- for (i = 0; i < dbmp->nreg; ++i)
+ for (i = 0; i < dbenv->mp_ncache; ++i)
dbmp->reginfo[i].primary =
R_ADDR(&dbmp->reginfo[i], dbmp->reginfo[i].rp->primary);
@@ -147,9 +148,9 @@ __memp_open(dbenv)
err: dbenv->mp_handle = NULL;
if (dbmp->reginfo != NULL && dbmp->reginfo[0].addr != NULL) {
- for (i = 0; i < dbmp->nreg; ++i)
+ for (i = 0; i < dbenv->mp_ncache; ++i)
if (dbmp->reginfo[i].id != INVALID_REGION_ID)
- (void)__db_r_detach(
+ (void)__env_region_detach(
dbenv, &dbmp->reginfo[i], 0);
__os_free(dbenv, dbmp->reginfo);
}
@@ -162,27 +163,32 @@ err: dbenv->mp_handle = NULL;
/*
* __memp_init --
* Initialize a MPOOL structure in shared memory.
+ *
+ * PUBLIC: int __memp_init
+ * PUBLIC: __P((DB_ENV *, DB_MPOOL *, u_int, u_int32_t, u_int));
*/
-static int
-__memp_init(dbenv, dbmp, reginfo_off, htab_buckets)
+int
+__memp_init(dbenv, dbmp, reginfo_off, htab_buckets, max_nreg)
DB_ENV *dbenv;
DB_MPOOL *dbmp;
- u_int reginfo_off;
+ u_int reginfo_off, max_nreg;
u_int32_t htab_buckets;
{
+ BH_FROZEN_ALLOC *frozen;
+ BH *frozen_bhp;
DB_MPOOL_HASH *htab, *hp;
- MPOOL *mp;
- REGINFO *reginfo;
+ MPOOL *mp, *main_mp;
+ REGINFO *infop;
+ db_mutex_t mtx_base, mtx_discard, mtx_prev;
u_int32_t i;
int ret;
void *p;
- reginfo = &dbmp->reginfo[reginfo_off];
- if ((ret = __db_shalloc(
- reginfo, sizeof(MPOOL), 0, &reginfo->primary)) != 0)
+ infop = &dbmp->reginfo[reginfo_off];
+ if ((ret = __env_alloc(infop, sizeof(MPOOL), &infop->primary)) != 0)
goto mem_err;
- reginfo->rp->primary = R_OFFSET(reginfo, reginfo->primary);
- mp = reginfo->primary;
+ infop->rp->primary = R_OFFSET(infop, infop->primary);
+ mp = infop->primary;
memset(mp, 0, sizeof(*mp));
if ((ret =
@@ -192,17 +198,19 @@ __memp_init(dbenv, dbmp, reginfo_off, htab_buckets)
if (reginfo_off == 0) {
ZERO_LSN(mp->lsn);
- mp->nreg = dbmp->nreg;
- if ((ret = __db_shalloc(&dbmp->reginfo[0],
- dbmp->nreg * sizeof(u_int32_t), 0, &p)) != 0)
+ mp->nreg = dbenv->mp_ncache;
+ mp->max_nreg = max_nreg;
+ if ((ret = __env_alloc(&dbmp->reginfo[0],
+ max_nreg * sizeof(u_int32_t), &p)) != 0)
goto mem_err;
mp->regids = R_OFFSET(dbmp->reginfo, p);
+ mp->nbuckets = dbenv->mp_ncache * htab_buckets;
/* Allocate file table space and initialize it. */
- if ((ret = __db_shalloc(reginfo,
- MPOOL_FILE_BUCKETS * sizeof(DB_MPOOL_HASH), 0, &htab)) != 0)
+ if ((ret = __env_alloc(infop,
+ MPOOL_FILE_BUCKETS * sizeof(DB_MPOOL_HASH), &htab)) != 0)
goto mem_err;
- mp->ftab = R_OFFSET(reginfo, htab);
+ mp->ftab = R_OFFSET(infop, htab);
for (i = 0; i < MPOOL_FILE_BUCKETS; i++) {
if ((ret = __mutex_alloc(dbenv,
MTX_MPOOL_FILE_BUCKET, 0, &htab[i].mtx_hash)) != 0)
@@ -211,32 +219,80 @@ __memp_init(dbenv, dbmp, reginfo_off, htab_buckets)
htab[i].hash_page_dirty = htab[i].hash_priority = 0;
}
+ /*
+ * Allocate all of the hash bucket mutexes up front. We do
+ * this so that we don't need to free and reallocate mutexes as
+ * the cache is resized.
+ */
+ mtx_base = mtx_prev = MUTEX_INVALID;
+ for (i = 0; i < mp->max_nreg * htab_buckets; i++) {
+ if ((ret = __mutex_alloc(dbenv, MTX_MPOOL_HASH_BUCKET,
+ 0, &mtx_discard)) != 0)
+ return (ret);
+ if (i == 0) {
+ mtx_base = mtx_discard;
+ mtx_prev = mtx_discard - 1;
+ }
+ DB_ASSERT(dbenv, mtx_discard == mtx_prev + 1 ||
+ mtx_base == MUTEX_INVALID);
+ mtx_prev = mtx_discard;
+ if ((ret = __mutex_alloc(dbenv, MTX_MPOOL_IO,
+ DB_MUTEX_SELF_BLOCK, &mtx_discard)) != 0)
+ return (ret);
+ DB_ASSERT(dbenv, mtx_discard == mtx_prev + 1 ||
+ mtx_base == MUTEX_INVALID);
+ mtx_prev = mtx_discard;
+ }
+ } else {
+ main_mp = dbmp->reginfo[0].primary;
+ htab = R_ADDR(&dbmp->reginfo[0], main_mp->htab);
+ mtx_base = htab[0].mtx_hash;
}
+ if (mtx_base != MUTEX_INVALID)
+ mtx_base += reginfo_off * htab_buckets;
+
/* Allocate hash table space and initialize it. */
- if ((ret = __db_shalloc(reginfo,
- htab_buckets * sizeof(DB_MPOOL_HASH), 0, &htab)) != 0)
+ if ((ret = __env_alloc(infop,
+ htab_buckets * sizeof(DB_MPOOL_HASH), &htab)) != 0)
goto mem_err;
- mp->htab = R_OFFSET(reginfo, htab);
+ mp->htab = R_OFFSET(infop, htab);
for (i = 0; i < htab_buckets; i++) {
hp = &htab[i];
- if ((ret = __mutex_alloc(dbenv,
- MTX_MPOOL_HASH_BUCKET, 0, &hp->mtx_hash)) != 0)
- return (ret);
- if ((ret = __mutex_alloc(dbenv,
- MTX_MPOOL_IO, DB_MUTEX_SELF_BLOCK, &hp->mtx_io)) != 0)
- return (ret);
+ hp->mtx_hash = (mtx_base == MUTEX_INVALID) ? MUTEX_INVALID :
+ mtx_base + i * 2;
+ hp->mtx_io = (mtx_base == MUTEX_INVALID) ? MUTEX_INVALID :
+ mtx_base + i * 2 + 1;
SH_TAILQ_INIT(&hp->hash_bucket);
- hp->hash_page_dirty = hp->hash_priority = hp->hash_io_wait = 0;
+ hp->hash_page_dirty = hp->hash_priority = 0;
+#ifdef HAVE_STATISTICS
+ hp->hash_io_wait = 0;
+ hp->hash_frozen = hp->hash_thawed = hp->hash_frozen_freed = 0;
+#endif
hp->flags = 0;
ZERO_LSN(hp->old_reader);
}
- mp->htab_buckets = mp->stat.st_hash_buckets = htab_buckets;
+ mp->htab_buckets = htab_buckets;
+#ifdef HAVE_STATISTICS
+ mp->stat.st_hash_buckets = htab_buckets;
+#endif
SH_TAILQ_INIT(&mp->free_frozen);
SH_TAILQ_INIT(&mp->alloc_frozen);
/*
+ * Pre-allocate one frozen buffer header. This avoids situations where
+ * the cache becomes full of pages and we don't even have the 28 bytes
+ * (or so) available to allocate a frozen buffer header.
+ */
+ if ((ret = __env_alloc(infop,
+ sizeof(BH_FROZEN_ALLOC) + sizeof(BH_FROZEN_PAGE), &frozen)) != 0)
+ goto mem_err;
+ frozen_bhp = (BH *)(frozen + 1);
+ SH_TAILQ_INSERT_TAIL(&mp->alloc_frozen, frozen, links);
+ SH_TAILQ_INSERT_TAIL(&mp->free_frozen, frozen_bhp, hq);
+
+ /*
* Only the environment creator knows the total cache size, fill in
* those statistics now.
*/
@@ -249,6 +305,25 @@ mem_err:__db_errx(dbenv, "Unable to allocate memory for mpool region");
}
/*
+ * PUBLIC: u_int32_t __memp_max_regions __P((DB_ENV *));
+ */
+u_int32_t
+__memp_max_regions(dbenv)
+ DB_ENV *dbenv;
+{
+ roff_t reg_size, max_size;
+ u_int32_t max_nreg;
+
+ __memp_region_size(dbenv, &reg_size, NULL);
+ max_size = (roff_t)dbenv->mp_max_gbytes * GIGABYTE +
+ dbenv->mp_max_bytes;
+ max_nreg = (max_size + reg_size / 2) / reg_size;
+ if (max_nreg <= dbenv->mp_ncache)
+ max_nreg = dbenv->mp_ncache;
+ return (max_nreg);
+}
+
+/*
* __memp_region_size --
* Size the region and figure out how many hash buckets we'll have.
*/
@@ -258,15 +333,16 @@ __memp_region_size(dbenv, reg_sizep, htab_bucketsp)
roff_t *reg_sizep;
u_int32_t *htab_bucketsp;
{
- roff_t reg_size;
+ roff_t reg_size, cache_size;
/*
* Figure out how big each cache region is. Cast an operand to roff_t
* so we do 64-bit arithmetic as appropriate.
*/
- reg_size = ((roff_t)GIGABYTE / dbenv->mp_ncache) * dbenv->mp_gbytes;
- reg_size += dbenv->mp_bytes / dbenv->mp_ncache;
- *reg_sizep = reg_size;
+ cache_size = (roff_t)dbenv->mp_gbytes * GIGABYTE + dbenv->mp_bytes;
+ reg_size = cache_size / dbenv->mp_ncache;
+ if (reg_sizep != NULL)
+ *reg_sizep = reg_size;
/*
* Figure out how many hash buckets each region will have. Assume we
@@ -281,7 +357,9 @@ __memp_region_size(dbenv, reg_sizep, htab_bucketsp)
* something we need to worry about right now, but is checked when the
* cache size is set.
*/
- *htab_bucketsp = __db_tablesize((u_int32_t)(reg_size / (10 * 1024)));
+ if (htab_bucketsp != NULL)
+ *htab_bucketsp =
+ __db_tablesize((u_int32_t)(reg_size / (10 * 1024)));
}
/*
@@ -294,10 +372,9 @@ u_int32_t
__memp_region_mutex_count(dbenv)
DB_ENV *dbenv;
{
- roff_t reg_size;
u_int32_t htab_buckets;
- __memp_region_size(dbenv, &reg_size, &htab_buckets);
+ __memp_region_size(dbenv, NULL, &htab_buckets);
/*
* We need a couple of mutexes for the region itself, one for each
@@ -334,13 +411,13 @@ __memp_init_config(dbenv, mp)
}
/*
- * __memp_dbenv_refresh --
+ * __memp_env_refresh --
* Clean up after the mpool system on a close or failed open.
*
- * PUBLIC: int __memp_dbenv_refresh __P((DB_ENV *));
+ * PUBLIC: int __memp_env_refresh __P((DB_ENV *));
*/
int
-__memp_dbenv_refresh(dbenv)
+__memp_env_refresh(dbenv)
DB_ENV *dbenv;
{
BH *bhp;
@@ -349,53 +426,72 @@ __memp_dbenv_refresh(dbenv)
DB_MPOOLFILE *dbmfp;
DB_MPOOL_HASH *hp;
DB_MPREG *mpreg;
- MPOOL *mp;
- REGINFO *reginfo;
- u_int32_t bucket, i;
+ MPOOL *mp, *c_mp;
+ REGINFO *infop;
+ db_mutex_t mtx_base, mtx;
+ u_int32_t bucket, htab_buckets, i, max_nreg, nreg;
int ret, t_ret;
ret = 0;
dbmp = dbenv->mp_handle;
+ mp = dbmp->reginfo[0].primary;
+ htab_buckets = mp->htab_buckets;
+ nreg = mp->nreg;
+ max_nreg = mp->max_nreg;
+ hp = R_ADDR(&dbmp->reginfo[0], mp->htab);
+ mtx_base = hp->mtx_hash;
/*
* If a private region, return the memory to the heap. Not needed for
* filesystem-backed or system shared memory regions, that memory isn't
* owned by any particular process.
- *
- * Discard buffers.
*/
- if (F_ISSET(dbenv, DB_ENV_PRIVATE))
- for (i = 0; i < dbmp->nreg; ++i) {
- reginfo = &dbmp->reginfo[i];
- mp = reginfo->primary;
- for (hp = R_ADDR(reginfo, mp->htab), bucket = 0;
- bucket < mp->htab_buckets; ++hp, ++bucket) {
- while ((bhp = SH_TAILQ_FIRST(
- &hp->hash_bucket, __bh)) != NULL)
- if (F_ISSET(bhp, BH_FROZEN))
- SH_TAILQ_REMOVE(
- &hp->hash_bucket, bhp,
- hq, __bh);
- else if ((t_ret = __memp_bhfree(
- dbmp, hp, bhp,
+ if (!F_ISSET(dbenv, DB_ENV_PRIVATE))
+ goto not_priv;
+
+ /* Discard buffers. */
+ for (i = 0; i < nreg; ++i) {
+ infop = &dbmp->reginfo[i];
+ c_mp = infop->primary;
+ for (hp = R_ADDR(infop, c_mp->htab), bucket = 0;
+ bucket < c_mp->htab_buckets; ++hp, ++bucket) {
+ while ((bhp = SH_TAILQ_FIRST(
+ &hp->hash_bucket, __bh)) != NULL)
+ if (F_ISSET(bhp, BH_FROZEN))
+ SH_TAILQ_REMOVE(
+ &hp->hash_bucket, bhp,
+ hq, __bh);
+ else {
+ if (F_ISSET(bhp, BH_DIRTY)) {
+ --hp->hash_page_dirty;
+ F_CLR(bhp,
+ BH_DIRTY | BH_DIRTY_CREATE);
+ }
+ if ((t_ret = __memp_bhfree(
+ dbmp, infop, hp, bhp,
BH_FREE_FREEMEM |
BH_FREE_UNLOCKED)) != 0 && ret == 0)
ret = t_ret;
- if ((t_ret = __mutex_free(
- dbenv, &hp->mtx_hash)) != 0 && ret == 0)
- ret = t_ret;
- if ((t_ret = __mutex_free(
- dbenv, &hp->mtx_io)) != 0 && ret == 0)
- ret = t_ret;
- }
- while ((frozen_alloc = SH_TAILQ_FIRST(
- &mp->alloc_frozen, __bh_frozen_a)) != NULL) {
- SH_TAILQ_REMOVE(&mp->alloc_frozen, frozen_alloc,
- links, __bh_frozen_a);
- __db_shalloc_free(reginfo, frozen_alloc);
- }
+ }
+ }
+ while ((frozen_alloc = SH_TAILQ_FIRST(
+ &c_mp->alloc_frozen, __bh_frozen_a)) != NULL) {
+ SH_TAILQ_REMOVE(&c_mp->alloc_frozen, frozen_alloc,
+ links, __bh_frozen_a);
+ __env_alloc_free(infop, frozen_alloc);
+ }
+ }
+
+ /* Discard hash bucket mutexes. */
+ if (mtx_base != MUTEX_INVALID)
+ for (i = 0; i < 2 * max_nreg * htab_buckets; ++i) {
+ mtx = mtx_base + i;
+ if ((t_ret = __mutex_free(dbenv, &mtx)) != 0 &&
+ ret == 0)
+ ret = t_ret;
}
+not_priv:
/* Discard DB_MPOOLFILEs. */
while ((dbmfp = TAILQ_FIRST(&dbmp->dbmfq)) != NULL)
if ((t_ret = __memp_fclose(dbmfp, 0)) != 0 && ret == 0)
@@ -415,25 +511,25 @@ __memp_dbenv_refresh(dbenv)
if (F_ISSET(dbenv, DB_ENV_PRIVATE)) {
/* Discard REGION IDs. */
- reginfo = &dbmp->reginfo[0];
- mp = dbmp->reginfo[0].primary;
- __memp_free(reginfo, NULL, R_ADDR(reginfo, mp->regids));
+ infop = &dbmp->reginfo[0];
+ __memp_free(infop, NULL, R_ADDR(infop, mp->regids));
/* Discard the File table. */
- __memp_free(reginfo, NULL, R_ADDR(reginfo, mp->ftab));
+ __memp_free(infop, NULL, R_ADDR(infop, mp->ftab));
/* Discard Hash tables. */
- for (i = 0; i < dbmp->nreg; ++i) {
- reginfo = &dbmp->reginfo[i];
- mp = reginfo->primary;
- __memp_free(reginfo, NULL, R_ADDR(reginfo, mp->htab));
+ for (i = 0; i < nreg; ++i) {
+ infop = &dbmp->reginfo[i];
+ c_mp = infop->primary;
+ __memp_free(infop, NULL, R_ADDR(infop, c_mp->htab));
}
}
/* Detach from the region. */
- for (i = 0; i < dbmp->nreg; ++i) {
- reginfo = &dbmp->reginfo[i];
- if ((t_ret = __db_r_detach(dbenv, reginfo, 0)) != 0 && ret == 0)
+ for (i = 0; i < nreg; ++i) {
+ infop = &dbmp->reginfo[i];
+ if ((t_ret =
+ __env_region_detach(dbenv, infop, 0)) != 0 && ret == 0)
ret = t_ret;
}
diff --git a/db/mp/mp_register.c b/db/mp/mp_register.c
index 1ca5f8311..ef5269d42 100644
--- a/db/mp/mp_register.c
+++ b/db/mp/mp_register.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_register.c,v 12.11 2006/08/24 14:46:15 bostic Exp $
+ * $Id: mp_register.c,v 12.13 2007/05/17 15:15:45 bostic Exp $
*/
#include "db_config.h"
diff --git a/db/mp/mp_resize.c b/db/mp/mp_resize.c
new file mode 100644
index 000000000..241f37e4b
--- /dev/null
+++ b/db/mp/mp_resize.c
@@ -0,0 +1,559 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2006,2007 Oracle. All rights reserved.
+ *
+ * $Id: mp_resize.c,v 12.5 2007/06/05 11:55:28 mjc Exp $
+ */
+
+#include "db_config.h"
+
+#include "db_int.h"
+#include "dbinc/mp.h"
+#include "dbinc/txn.h"
+
+static int __memp_add_bucket __P((DB_MPOOL *));
+static int __memp_add_region __P((DB_MPOOL *));
+static int __memp_map_regions __P((DB_MPOOL *));
+static int __memp_merge_buckets
+ __P((DB_MPOOL *, u_int32_t, u_int32_t, u_int32_t));
+static int __memp_remove_bucket __P((DB_MPOOL *));
+static int __memp_remove_region __P((DB_MPOOL *));
+
+/*
+ * PUBLIC: int __memp_get_bucket
+ * PUBLIC: __P((DB_MPOOLFILE *, db_pgno_t, REGINFO **, DB_MPOOL_HASH **));
+ */
+int
+__memp_get_bucket(dbmfp, pgno, infopp, hpp)
+ DB_MPOOLFILE *dbmfp;
+ db_pgno_t pgno;
+ REGINFO **infopp;
+ DB_MPOOL_HASH **hpp;
+{
+ DB_ENV *dbenv;
+ DB_MPOOL *dbmp;
+ DB_MPOOL_HASH *hp;
+ MPOOL *c_mp, *mp;
+ REGINFO *infop;
+ roff_t mf_offset;
+ u_int32_t bucket, nbuckets, new_bucket, new_nbuckets, region;
+ u_int32_t *regids;
+ int ret;
+
+ dbenv = dbmfp->dbenv;
+ dbmp = dbenv->mp_handle;
+ mf_offset = R_OFFSET(dbmp->reginfo, dbmfp->mfp);
+ mp = dbmp->reginfo[0].primary;
+ ret = 0;
+
+ for (;;) {
+ nbuckets = mp->nbuckets;
+ MP_BUCKET(mf_offset, pgno, nbuckets, bucket);
+
+ /*
+ * Once we work out which region we are looking in, we have to
+ * check that we have that region mapped, and that the version
+ * we have matches the ID in the main mpool region. Otherwise
+ * we have to go and map in any regions that don't match and
+ * retry.
+ */
+ region = NREGION(mp, bucket);
+ regids = R_ADDR(dbmp->reginfo, mp->regids);
+
+ for (;;) {
+ infop = *infopp = &dbmp->reginfo[region];
+ c_mp = infop->primary;
+
+ /* If we have the correct region mapped, we're done. */
+ if (c_mp != NULL && regids[region] == infop->id)
+ break;
+ if ((ret = __memp_map_regions(dbmp)) != 0)
+ return (ret);
+ }
+
+ /* If our caller wants the hash bucket, lock it here. */
+ if (hpp != NULL) {
+ hp = R_ADDR(infop, c_mp->htab);
+ hp = &hp[bucket - region * mp->htab_buckets];
+
+ MUTEX_LOCK(dbenv, hp->mtx_hash);
+
+ /*
+ * Check that we still have the correct region mapped.
+ */
+ if (regids[region] != infop->id) {
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
+ continue;
+ }
+
+ /*
+ * Now that the bucket is locked, we need to check that
+ * the cache has not been resized while we waited.
+ */
+ new_nbuckets = mp->nbuckets;
+ if (nbuckets != new_nbuckets) {
+ MP_BUCKET(mf_offset, pgno, new_nbuckets,
+ new_bucket);
+
+ if (new_bucket != bucket) {
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
+ continue;
+ }
+ }
+
+ *hpp = hp;
+ }
+
+ break;
+ }
+
+ return (ret);
+}
+
+static int
+__memp_merge_buckets(dbmp, new_nbuckets, old_bucket, new_bucket)
+ DB_MPOOL *dbmp;
+ u_int32_t new_nbuckets, old_bucket, new_bucket;
+{
+ BH *alloc_bhp, *bhp, *current_bhp, *new_bhp, *next_bhp;
+ DB_ENV *dbenv;
+ DB_MPOOL_HASH *new_hp, *old_hp;
+ MPOOL *mp, *new_mp, *old_mp;
+ MPOOLFILE *mfp;
+ REGINFO *new_infop, *old_infop;
+ u_int32_t bucket, high_mask, new_region, old_region;
+ int ret;
+
+ dbenv = dbmp->dbenv;
+ mp = dbmp->reginfo[0].primary;
+ new_bhp = NULL;
+ ret = 0;
+
+ MP_MASK(new_nbuckets, high_mask);
+
+ old_region = NREGION(mp, old_bucket);
+ old_infop = &dbmp->reginfo[old_region];
+ old_mp = old_infop->primary;
+ old_hp = R_ADDR(old_infop, old_mp->htab);
+ old_hp = &old_hp[old_bucket - old_region * mp->htab_buckets];
+
+ new_region = NREGION(mp, new_bucket);
+ new_infop = &dbmp->reginfo[new_region];
+ new_mp = new_infop->primary;
+ new_hp = R_ADDR(new_infop, new_mp->htab);
+ new_hp = &new_hp[new_bucket - new_region * mp->htab_buckets];
+
+ /*
+ * Before merging, we need to check that there are no old buffers left
+ * in the target hash bucket after a previous split.
+ */
+free_old:
+ MUTEX_LOCK(dbenv, new_hp->mtx_hash);
+ SH_TAILQ_FOREACH(bhp, &new_hp->hash_bucket, hq, __bh) {
+ MP_BUCKET(bhp->mf_offset, bhp->pgno, mp->nbuckets, bucket);
+
+ if (bucket != new_bucket) {
+ /*
+ * There is no way that an old buffer can be locked
+ * after a split, since everyone will look for it in
+ * the new hash bucket.
+ */
+ DB_ASSERT(dbenv, !F_ISSET(bhp, BH_LOCKED | BH_DIRTY) &&
+ bhp->ref == 0);
+ if ((ret = __memp_bhfree(dbmp,
+ new_infop, new_hp, bhp, BH_FREE_FREEMEM)) != 0) {
+ MUTEX_UNLOCK(dbenv, new_hp->mtx_hash);
+ return (ret);
+ }
+
+ /*
+ * The free has modified the list of buffers and
+ * dropped the mutex. We need to start again.
+ */
+ goto free_old;
+ }
+ }
+ MUTEX_UNLOCK(dbenv, new_hp->mtx_hash);
+
+ /*
+ * Before we begin, make sure that all of the buffers we care about are
+ * not in use and not frozen. We do this because we can't drop the old
+ * hash bucket mutex once we start moving buffers around.
+ */
+retry: MUTEX_LOCK(dbenv, old_hp->mtx_hash);
+ SH_TAILQ_FOREACH(bhp, &old_hp->hash_bucket, hq, __bh) {
+ MP_HASH_BUCKET(MP_HASH(bhp->mf_offset, bhp->pgno),
+ new_nbuckets, high_mask, bucket);
+
+ if (bucket == new_bucket &&
+ (F_ISSET(bhp, BH_LOCKED) || bhp->ref != 0)) {
+ MUTEX_UNLOCK(dbenv, old_hp->mtx_hash);
+ __os_yield(dbenv);
+ goto retry;
+ } else if (bucket == new_bucket && F_ISSET(bhp, BH_FROZEN)) {
+ if (BH_OBSOLETE(bhp, old_hp->old_reader))
+ alloc_bhp = NULL;
+ else {
+ ++bhp->ref;
+ mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset);
+ MUTEX_UNLOCK(dbenv, old_hp->mtx_hash);
+ if ((ret = __memp_alloc(dbmp,
+ old_infop, mfp, 0, NULL, &alloc_bhp)) != 0)
+ return (ret);
+ MUTEX_LOCK(dbenv, old_hp->mtx_hash);
+ }
+ if ((ret = __memp_bh_thaw(dbmp,
+ old_infop, old_hp, bhp, alloc_bhp)) != 0) {
+ MUTEX_UNLOCK(dbenv, old_hp->mtx_hash);
+ return (ret);
+ }
+
+ /*
+ * We've dropped the mutex in order to thaw, so we need
+ * to go back to the beginning and check that all of
+ * the buffers we care about are still unlocked and
+ * unreferenced.
+ */
+ MUTEX_UNLOCK(dbenv, old_hp->mtx_hash);
+ goto retry;
+ }
+ }
+
+ /*
+ * We now know that all of the buffers we care about are unlocked and
+ * unreferenced. Go ahead and copy them.
+ */
+ SH_TAILQ_FOREACH(bhp, &old_hp->hash_bucket, hq, __bh) {
+ MP_HASH_BUCKET(MP_HASH(bhp->mf_offset, bhp->pgno),
+ new_nbuckets, high_mask, bucket);
+ mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset);
+
+ /*
+ * We ignore buffers that don't hash to the new bucket. We
+ * could also ignore clean buffers which are not part of a
+ * multiversion chain as long as they have a backing file.
+ */
+ if (bucket != new_bucket || (!F_ISSET(bhp, BH_DIRTY) &&
+ SH_CHAIN_SINGLETON(bhp, vc) && !mfp->no_backing_file))
+ continue;
+
+ for (current_bhp = bhp, next_bhp = NULL;
+ current_bhp != NULL;
+ current_bhp = SH_CHAIN_PREV(current_bhp, vc, __bh),
+ next_bhp = alloc_bhp) {
+ if ((ret = __memp_alloc(dbmp,
+ new_infop, mfp, 0, NULL, &alloc_bhp)) != 0)
+ break;
+
+ alloc_bhp->ref = current_bhp->ref;
+ alloc_bhp->ref_sync = current_bhp->ref_sync;
+ alloc_bhp->priority = current_bhp->priority;
+ alloc_bhp->pgno = current_bhp->pgno;
+ alloc_bhp->mf_offset = current_bhp->mf_offset;
+ alloc_bhp->flags = current_bhp->flags;
+ alloc_bhp->td_off = current_bhp->td_off;
+
+ /*
+ * We've duplicated the buffer, so now we need to
+ * update reference counts, including the counts in the
+ * per-MPOOLFILE and the transaction detail (for MVCC
+ * buffers).
+ */
+ MUTEX_LOCK(dbenv, mfp->mutex);
+ ++mfp->block_cnt;
+ MUTEX_UNLOCK(dbenv, mfp->mutex);
+
+ if (alloc_bhp->td_off != INVALID_ROFF &&
+ (ret = __txn_add_buffer(dbenv,
+ R_ADDR(&dbenv->tx_handle->reginfo,
+ alloc_bhp->td_off))) != 0)
+ break;
+
+ memcpy(alloc_bhp->buf, bhp->buf, mfp->stat.st_pagesize);
+
+ /*
+ * We build up the MVCC chain first, then insert the
+ * head (stored in new_bhp) once.
+ */
+ if (next_bhp == NULL) {
+ SH_CHAIN_INIT(alloc_bhp, vc);
+ new_bhp = alloc_bhp;
+ } else
+ SH_CHAIN_INSERT_BEFORE(
+ next_bhp, alloc_bhp, vc, __bh);
+ }
+
+ MUTEX_LOCK(dbenv, new_hp->mtx_hash);
+ SH_TAILQ_INSERT_TAIL(&new_hp->hash_bucket, new_bhp, hq);
+ if (F_ISSET(new_bhp, BH_DIRTY))
+ ++new_hp->hash_page_dirty;
+
+ /*
+ * We're doing an insertion sort, so it is O(N**2), but since
+ * buckets should be small, that should not matter. When
+ * splitting a bucket, we traverse in priority order and append
+ * to the new bucket, and __memp_bucket_reorder is O(1) in that
+ * case.
+ */
+ __memp_bucket_reorder(dbenv, new_hp, new_bhp);
+ MUTEX_UNLOCK(dbenv, new_hp->mtx_hash);
+
+ if (F_ISSET(bhp, BH_DIRTY)) {
+ F_CLR(bhp, BH_DIRTY);
+ --old_hp->hash_page_dirty;
+ }
+ }
+
+ if (ret == 0)
+ mp->nbuckets = new_nbuckets;
+ MUTEX_UNLOCK(dbenv, old_hp->mtx_hash);
+
+ return (ret);
+}
+
+static int
+__memp_add_bucket(dbmp)
+ DB_MPOOL *dbmp;
+{
+ DB_ENV *dbenv;
+ MPOOL *mp;
+ u_int32_t high_mask, new_bucket, old_bucket;
+
+ dbenv = dbmp->dbenv;
+ mp = dbmp->reginfo[0].primary;
+
+ new_bucket = mp->nbuckets;
+ /* We should always be adding buckets to the last region. */
+ DB_ASSERT(dbenv, NREGION(mp, new_bucket) == mp->nreg - 1);
+ MP_MASK(mp->nbuckets, high_mask);
+ old_bucket = new_bucket & (high_mask >> 1);
+
+ /*
+ * With fixed-sized regions, the new region is always smaller than the
+ * existing total cache size, so buffers always need to be copied. If
+ * we implement variable region sizes, it's possible that we will be
+ * splitting a hash bucket in the new region. Catch that here.
+ */
+ DB_ASSERT(dbenv, NREGION(mp, old_bucket) != NREGION(mp, new_bucket));
+
+ return (__memp_merge_buckets(dbmp, mp->nbuckets + 1,
+ old_bucket, new_bucket));
+}
+
+static int
+__memp_add_region(dbmp)
+ DB_MPOOL *dbmp;
+{
+ DB_ENV *dbenv;
+ MPOOL *mp;
+ REGINFO *infop;
+ int ret;
+ roff_t reg_size;
+ u_int i;
+ u_int32_t *regids;
+
+ dbenv = dbmp->dbenv;
+ mp = dbmp->reginfo[0].primary;
+ /* All cache regions are the same size. */
+ reg_size = dbmp->reginfo[0].rp->size;
+ ret = 0;
+
+ infop = &dbmp->reginfo[mp->nreg];
+ infop->dbenv = dbenv;
+ infop->type = REGION_TYPE_MPOOL;
+ infop->id = INVALID_REGION_ID;
+ infop->flags = REGION_CREATE_OK;
+ if ((ret = __env_region_attach(dbenv, infop, reg_size)) != 0)
+ return (ret);
+ if ((ret = __memp_init(dbenv,
+ dbmp, mp->nreg, mp->htab_buckets, mp->max_nreg)) != 0)
+ return (ret);
+ regids = R_ADDR(dbmp->reginfo, mp->regids);
+ regids[mp->nreg++] = infop->id;
+
+ for (i = 0; i < mp->htab_buckets; i++)
+ if ((ret = __memp_add_bucket(dbmp)) != 0)
+ break;
+
+ return (ret);
+}
+
+static int
+__memp_remove_bucket(dbmp)
+ DB_MPOOL *dbmp;
+{
+ DB_ENV *dbenv;
+ MPOOL *mp;
+ u_int32_t high_mask, new_bucket, old_bucket;
+
+ dbenv = dbmp->dbenv;
+ mp = dbmp->reginfo[0].primary;
+
+ old_bucket = mp->nbuckets - 1;
+
+ /* We should always be removing buckets from the last region. */
+ DB_ASSERT(dbenv, NREGION(mp, old_bucket) == mp->nreg - 1);
+ MP_MASK(mp->nbuckets - 1, high_mask);
+ new_bucket = old_bucket & (high_mask >> 1);
+
+ return (__memp_merge_buckets(dbmp, mp->nbuckets - 1,
+ old_bucket, new_bucket));
+}
+
+static int
+__memp_remove_region(dbmp)
+ DB_MPOOL *dbmp;
+{
+ DB_ENV *dbenv;
+ MPOOL *mp;
+ REGINFO *infop;
+ int ret;
+ u_int i;
+
+ dbenv = dbmp->dbenv;
+ mp = dbmp->reginfo[0].primary;
+ ret = 0;
+
+ if (mp->nreg == 1) {
+ __db_errx(dbenv, "cannot remove the last cache");
+ return (EINVAL);
+ }
+
+ for (i = 0; i < mp->htab_buckets; i++)
+ if ((ret = __memp_remove_bucket(dbmp)) != 0)
+ return (ret);
+
+ /* Detach from the region then destroy it. */
+ infop = &dbmp->reginfo[--mp->nreg];
+ return (__env_region_detach(dbenv, infop, 1));
+}
+
+static int
+__memp_map_regions(dbmp)
+ DB_MPOOL *dbmp;
+{
+ DB_ENV *dbenv;
+ MPOOL *mp;
+ int ret;
+ u_int i;
+ u_int32_t *regids;
+
+ dbenv = dbmp->dbenv;
+ mp = dbmp->reginfo[0].primary;
+ regids = R_ADDR(dbmp->reginfo, mp->regids);
+ ret = 0;
+
+ for (i = 1; i < mp->nreg; ++i) {
+ if (dbmp->reginfo[i].primary != NULL &&
+ dbmp->reginfo[i].id == regids[i])
+ continue;
+
+ if (dbmp->reginfo[i].primary != NULL)
+ ret = __env_region_detach(dbenv, &dbmp->reginfo[i], 0);
+
+ dbmp->reginfo[i].dbenv = dbenv;
+ dbmp->reginfo[i].type = REGION_TYPE_MPOOL;
+ dbmp->reginfo[i].id = regids[i];
+ dbmp->reginfo[i].flags = REGION_JOIN_OK;
+ if ((ret =
+ __env_region_attach(dbenv, &dbmp->reginfo[i], 0)) != 0)
+ return (ret);
+ dbmp->reginfo[i].primary = R_ADDR(&dbmp->reginfo[i],
+ dbmp->reginfo[i].rp->primary);
+ }
+
+ for (; i < mp->max_nreg; i++)
+ if (dbmp->reginfo[i].primary != NULL &&
+ (ret = __env_region_detach(dbenv,
+ &dbmp->reginfo[i], 0)) != 0)
+ break;
+
+ return (ret);
+}
+
+/*
+ * PUBLIC: int __memp_resize __P((DB_MPOOL *, u_int32_t, u_int32_t));
+ */
+int
+__memp_resize(dbmp, gbytes, bytes)
+ DB_MPOOL *dbmp;
+ u_int32_t gbytes, bytes;
+{
+ DB_ENV *dbenv;
+ MPOOL *mp;
+ int ret;
+ u_int32_t ncache;
+ roff_t reg_size, total_size;
+
+ dbenv = dbmp->dbenv;
+ mp = dbmp->reginfo[0].primary;
+ reg_size = dbmp->reginfo[0].rp->size;
+ total_size = (roff_t)gbytes * GIGABYTE + bytes;
+ ncache = (u_int32_t)((total_size + reg_size / 2) / reg_size);
+
+ if (ncache < 1)
+ ncache = 1;
+ else if (ncache > mp->max_nreg) {
+ __db_errx(dbenv,
+ "cannot resize to %lu cache regions: maximum is %lu",
+ (u_long)ncache, (u_long)mp->max_nreg);
+ return (EINVAL);
+ }
+
+ ret = 0;
+ MUTEX_LOCK(dbenv, mp->mtx_resize);
+ while (mp->nreg != ncache)
+ if ((ret = (mp->nreg < ncache ?
+ __memp_add_region(dbmp) :
+ __memp_remove_region(dbmp))) != 0)
+ break;
+ MUTEX_UNLOCK(dbenv, mp->mtx_resize);
+
+ return (ret);
+}
+
+/*
+ * PUBLIC: int __memp_get_cache_max __P((DB_ENV *, u_int32_t *, u_int32_t *));
+ */
+int
+__memp_get_cache_max(dbenv, max_gbytesp, max_bytesp)
+ DB_ENV *dbenv;
+ u_int32_t *max_gbytesp, *max_bytesp;
+{
+ DB_MPOOL *dbmp;
+ MPOOL *mp;
+ roff_t reg_size, max_size;
+
+ ENV_NOT_CONFIGURED(dbenv,
+ dbenv->mp_handle, "DB_ENV->get_mp_max_ncache", DB_INIT_MPOOL);
+
+ if (MPOOL_ON(dbenv)) {
+ dbmp = dbenv->mp_handle;
+ mp = dbmp->reginfo[0].primary;
+ reg_size = dbmp->reginfo[0].rp->size;
+ max_size = mp->max_nreg * reg_size;
+ *max_gbytesp = (u_int32_t)(max_size / GIGABYTE);
+ *max_bytesp = (u_int32_t)(max_size % GIGABYTE);
+ } else {
+ *max_gbytesp = dbenv->mp_max_gbytes;
+ *max_bytesp = dbenv->mp_max_bytes;
+ }
+
+ return (0);
+}
+
+/*
+ * PUBLIC: int __memp_set_cache_max __P((DB_ENV *, u_int32_t, u_int32_t));
+ */
+int
+__memp_set_cache_max(dbenv, max_gbytes, max_bytes)
+ DB_ENV *dbenv;
+ u_int32_t max_gbytes, max_bytes;
+{
+ ENV_ILLEGAL_AFTER_OPEN(dbenv, "DB_ENV->set_cache_max");
+ dbenv->mp_max_gbytes = max_gbytes;
+ dbenv->mp_max_bytes = max_bytes;
+
+ return (0);
+}
diff --git a/db/mp/mp_stat.c b/db/mp/mp_stat.c
index b4d4544b5..0e7b6c237 100644
--- a/db/mp/mp_stat.c
+++ b/db/mp/mp_stat.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_stat.c,v 12.28 2006/09/11 14:53:42 bostic Exp $
+ * $Id: mp_stat.c,v 12.36 2007/06/22 17:41:29 bostic Exp $
*/
#include "db_config.h"
@@ -104,10 +103,10 @@ __memp_stat(dbenv, gspp, fspp, flags)
* a per-cache basis. Note that configuration information
* may be modified at any time, and so we have to lock.
*/
- c_mp = dbmp->reginfo[0].primary;
- sp->st_gbytes = c_mp->stat.st_gbytes;
- sp->st_bytes = c_mp->stat.st_bytes;
- sp->st_ncache = dbmp->nreg;
+ sp->st_gbytes = mp->stat.st_gbytes;
+ sp->st_bytes = mp->stat.st_bytes;
+ sp->st_ncache = mp->nreg;
+ sp->st_max_ncache = mp->max_nreg;
sp->st_regsize = dbmp->reginfo[0].rp->size;
MPOOL_SYSTEM_LOCK(dbenv);
@@ -165,7 +164,8 @@ __memp_stat(dbenv, gspp, fspp, flags)
c_mp->stat.st_alloc_max_pages;
if (LF_ISSET(DB_STAT_CLEAR)) {
- __mutex_clear(dbenv, c_mp->mtx_region);
+ if (!LF_ISSET(DB_STAT_SUBSYSTEM))
+ __mutex_clear(dbenv, c_mp->mtx_region);
MPOOL_SYSTEM_LOCK(dbenv);
st_bytes = c_mp->stat.st_bytes;
@@ -388,9 +388,10 @@ __memp_stat_print(dbenv, flags)
int ret;
orig_flags = flags;
- LF_CLR(DB_STAT_CLEAR);
+ LF_CLR(DB_STAT_CLEAR | DB_STAT_SUBSYSTEM);
if (flags == 0 || LF_ISSET(DB_STAT_ALL)) {
- ret = __memp_print_stats(dbenv, orig_flags);
+ ret = __memp_print_stats(dbenv,
+ LF_ISSET(DB_STAT_ALL) ? flags : orig_flags);
if (flags == 0 || ret != 0)
return (ret);
}
@@ -423,6 +424,7 @@ __memp_print_stats(dbenv, flags)
__db_dlbytes(dbenv, "Total cache size",
(u_long)gsp->st_gbytes, (u_long)0, (u_long)gsp->st_bytes);
__db_dl(dbenv, "Number of caches", (u_long)gsp->st_ncache);
+ __db_dl(dbenv, "Maximum number of caches", (u_long)gsp->st_max_ncache);
__db_dlbytes(dbenv, "Pool individual cache size",
(u_long)0, (u_long)0, (u_long)gsp->st_regsize);
__db_dlbytes(dbenv, "Maximum memory-mapped file size",
@@ -551,7 +553,7 @@ __memp_print_all(dbenv, flags)
MPOOL_SYSTEM_LOCK(dbenv);
- __db_print_reginfo(dbenv, dbmp->reginfo, "Mpool");
+ __db_print_reginfo(dbenv, dbmp->reginfo, "Mpool", flags);
__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
__db_msg(dbenv, "MPOOL structure:");
@@ -567,7 +569,7 @@ __memp_print_all(dbenv, flags)
__db_msg(dbenv, "DB_MPOOL handle information:");
__mutex_print_debug_single(
dbenv, "DB_MPOOL handle mutex", dbmp->mutex, flags);
- STAT_ULONG("Underlying cache regions", dbmp->nreg);
+ STAT_ULONG("Underlying cache regions", mp->nreg);
__db_msg(dbenv, "%s", DB_GLOBAL(db_line));
__db_msg(dbenv, "DB_MPOOLFILE structures:");
@@ -709,9 +711,11 @@ __memp_print_hash(dbenv, dbmp, reginfo, fmap, flags)
bucket = 0; bucket < c_mp->htab_buckets; ++hp, ++bucket) {
MUTEX_LOCK(dbenv, hp->mtx_hash);
if ((bhp = SH_TAILQ_FIRST(&hp->hash_bucket, __bh)) != NULL) {
- __db_msgadd(dbenv, &mb, "bucket %lu: %lu, %lu ",
+ __db_msgadd(dbenv, &mb,
+ "bucket %lu: %lu, %lu (%lu dirty)",
(u_long)bucket, (u_long)hp->hash_io_wait,
- (u_long)hp->hash_priority);
+ (u_long)hp->hash_priority,
+ (u_long)hp->hash_page_dirty);
if (hp->hash_frozen != 0)
__db_msgadd(dbenv, &mb, "(MVCC %lu/%lu/%lu) ",
(u_long)hp->hash_frozen,
@@ -822,7 +826,8 @@ __memp_stat_wait(dbenv, reginfo, mp, mstat, flags)
mstat->st_hash_max_wait = tmp_wait;
mstat->st_hash_max_nowait = tmp_nowait;
}
- if (LF_ISSET(DB_STAT_CLEAR))
+ if (LF_ISSET(DB_STAT_CLEAR |
+ DB_STAT_SUBSYSTEM) == DB_STAT_CLEAR)
__mutex_clear(dbenv, hp->mtx_hash);
mstat->st_io_wait += hp->hash_io_wait;
diff --git a/db/mp/mp_sync.c b/db/mp/mp_sync.c
index 898ae5b6d..5db83fc7b 100644
--- a/db/mp/mp_sync.c
+++ b/db/mp/mp_sync.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_sync.c,v 12.24 2006/08/24 14:46:15 bostic Exp $
+ * $Id: mp_sync.c,v 12.52 2007/06/01 18:32:44 bostic Exp $
*/
#include "db_config.h"
@@ -12,6 +11,8 @@
#include "db_int.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
+#include "dbinc/db_page.h"
+#include "dbinc/hash.h"
typedef struct {
DB_MPOOL_HASH *track_hp; /* Hash bucket. */
@@ -21,8 +22,8 @@ typedef struct {
} BH_TRACK;
static int __bhcmp __P((const void *, const void *));
-static int __memp_close_flush_files __P((DB_ENV *, DB_MPOOL *, int));
-static int __memp_sync_files __P((DB_ENV *, DB_MPOOL *));
+static int __memp_close_flush_files __P((DB_ENV *, int));
+static int __memp_sync_files __P((DB_ENV *));
static int __memp_sync_file __P((DB_ENV *,
MPOOLFILE *, void *, u_int32_t *, u_int32_t));
@@ -93,7 +94,7 @@ __memp_sync_pp(dbenv, lsnp)
dbenv->lg_handle, "memp_sync", DB_INIT_LOG);
ENV_ENTER(dbenv, ip);
- REPLICATION_WRAP(dbenv, (__memp_sync(dbenv, lsnp)), ret);
+ REPLICATION_WRAP(dbenv, (__memp_sync(dbenv, DB_SYNC_CACHE, lsnp)), ret);
ENV_LEAVE(dbenv, ip);
return (ret);
}
@@ -102,16 +103,17 @@ __memp_sync_pp(dbenv, lsnp)
* __memp_sync --
* DB_ENV->memp_sync.
*
- * PUBLIC: int __memp_sync __P((DB_ENV *, DB_LSN *));
+ * PUBLIC: int __memp_sync __P((DB_ENV *, u_int32_t, DB_LSN *));
*/
int
-__memp_sync(dbenv, lsnp)
+__memp_sync(dbenv, flags, lsnp)
DB_ENV *dbenv;
+ u_int32_t flags;
DB_LSN *lsnp;
{
DB_MPOOL *dbmp;
MPOOL *mp;
- int ret;
+ int interrupted, ret;
dbmp = dbenv->mp_handle;
mp = dbmp->reginfo[0].primary;
@@ -128,10 +130,11 @@ __memp_sync(dbenv, lsnp)
MPOOL_SYSTEM_UNLOCK(dbenv);
}
- if ((ret = __memp_sync_int(dbenv, NULL, 0, DB_SYNC_CACHE, NULL)) != 0)
+ if ((ret =
+ __memp_sync_int(dbenv, NULL, 0, flags, NULL, &interrupted)) != 0)
return (ret);
- if (lsnp != NULL) {
+ if (!interrupted && lsnp != NULL) {
MPOOL_SYSTEM_LOCK(dbenv);
if (LOG_COMPARE(lsnp, &mp->lsn) > 0)
mp->lsn = *lsnp;
@@ -195,7 +198,8 @@ __memp_fsync(dbmfp)
if (mfp->file_written == 0)
return (0);
- return (__memp_sync_int(dbmfp->dbenv, dbmfp, 0, DB_SYNC_FILE, NULL));
+ return (__memp_sync_int(
+ dbmfp->dbenv, dbmfp, 0, DB_SYNC_FILE, NULL, NULL));
}
/*
@@ -209,6 +213,8 @@ __mp_xxx_fh(dbmfp, fhp)
DB_MPOOLFILE *dbmfp;
DB_FH **fhp;
{
+ int ret;
+
/*
* This is a truly spectacular layering violation, intended ONLY to
* support compatibility for the DB 1.85 DB->fd call.
@@ -226,7 +232,10 @@ __mp_xxx_fh(dbmfp, fhp)
if ((*fhp = dbmfp->fhp) != NULL)
return (0);
- return (__memp_sync_int(dbmfp->dbenv, dbmfp, 0, DB_SYNC_FILE, NULL));
+ if ((ret = __memp_sync_int(
+ dbmfp->dbenv, dbmfp, 0, DB_SYNC_FILE, NULL, NULL)) == 0)
+ *fhp = dbmfp->fhp;
+ return (ret);
}
/*
@@ -234,14 +243,14 @@ __mp_xxx_fh(dbmfp, fhp)
* Mpool sync internal function.
*
* PUBLIC: int __memp_sync_int __P((DB_ENV *,
- * PUBLIC: DB_MPOOLFILE *, u_int32_t, db_sync_op, u_int32_t *));
+ * PUBLIC: DB_MPOOLFILE *, u_int32_t, u_int32_t, u_int32_t *, int *));
*/
int
-__memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
+__memp_sync_int(dbenv, dbmfp, trickle_max, flags, wrote_totalp, interruptedp)
DB_ENV *dbenv;
DB_MPOOLFILE *dbmfp;
- u_int32_t trickle_max, *wrotep;
- db_sync_op op;
+ u_int32_t trickle_max, flags, *wrote_totalp;
+ int *interruptedp;
{
BH *bhp;
BH_TRACK *bharray;
@@ -251,20 +260,32 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
MPOOLFILE *mfp;
db_mutex_t mutex;
roff_t last_mf_offset;
- u_int32_t ar_cnt, ar_max, i, n_cache, remaining, wrote;
- int filecnt, hb_lock, maxopenfd, maxwrite, maxwrite_sleep;
- int pass, ret, t_ret, wait_cnt, write_cnt;
+ u_int32_t ar_cnt, ar_max, dirty, i, n_cache, remaining, wrote_total;
+ int filecnt, maxopenfd, pass, required_write, ret, t_ret;
+ int wait_cnt, wrote_cnt;
dbmp = dbenv->mp_handle;
mp = dbmp->reginfo[0].primary;
last_mf_offset = INVALID_ROFF;
- filecnt = pass = wrote = 0;
+ filecnt = pass = wrote_total = 0;
+
+ if (wrote_totalp != NULL)
+ *wrote_totalp = 0;
+ if (interruptedp != NULL)
+ *interruptedp = 0;
+
+ /*
+ * If we're flushing the cache, it's a checkpoint or we're flushing a
+ * specific file, we really have to write the blocks and we have to
+ * confirm they made it to disk. Otherwise, we can skip a block if
+ * it's hard to get.
+ */
+ required_write = LF_ISSET(DB_SYNC_CACHE |
+ DB_SYNC_CHECKPOINT | DB_SYNC_FILE | DB_SYNC_QUEUE_EXTENT);
/* Get shared configuration information. */
MPOOL_SYSTEM_LOCK(dbenv);
maxopenfd = mp->mp_maxopenfd;
- maxwrite = mp->mp_maxwrite;
- maxwrite_sleep = mp->mp_maxwrite_sleep;
MPOOL_SYSTEM_UNLOCK(dbenv);
/* Assume one dirty page per bucket. */
@@ -284,43 +305,60 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
hp = R_ADDR(&dbmp->reginfo[n_cache], c_mp->htab);
for (i = 0; i < c_mp->htab_buckets; i++, hp++) {
/*
- * We can check for empty buckets before locking as we
- * only care if the pointer is zero or non-zero. We
- * can ignore empty buckets because we only need write
- * buffers that were dirty before we started.
+ * We can check for empty buckets before locking as
+ * we only care if the pointer is zero or non-zero.
+ * We can ignore empty or clean buckets because we
+ * only need write buffers that were dirty before
+ * we started.
*/
+#ifdef DIAGNOSTIC
if (SH_TAILQ_FIRST(&hp->hash_bucket, __bh) == NULL)
+#else
+ if (hp->hash_page_dirty == 0)
+#endif
continue;
+ dirty = 0;
MUTEX_LOCK(dbenv, hp->mtx_hash);
SH_TAILQ_FOREACH(bhp, &hp->hash_bucket, hq, __bh) {
/* Always ignore clean pages. */
if (!F_ISSET(bhp, BH_DIRTY))
continue;
+ dirty++;
mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset);
/*
- * Ignore in-memory files, even if they are
- * temp files to whom a backing file has been
- * allocated.
+ * Ignore in-memory files, unless the file is
+ * specifically being flushed.
*/
- if (mfp->no_backing_file ||
+ if (mfp->no_backing_file)
+ continue;
+ if (!LF_ISSET(DB_SYNC_FILE) &&
F_ISSET(mfp, MP_TEMP))
continue;
/*
- * If we're flushing a specific file, see if
- * this page is from that file.
+ * Ignore files that aren't involved in DB's
+ * transactional operations during checkpoints.
*/
- if (dbmfp != NULL && mfp != dbmfp->mfp)
+ if (LF_ISSET(DB_SYNC_CHECKPOINT) &&
+ mfp->lsn_off == DB_LSN_OFF_NOTSET)
continue;
/*
- * Ignore files that aren't involved in DB's
- * transactional operations during checkpoints.
+ * Ignore files that aren't Queue extent files
+ * if we're flushing a Queue file with extents.
*/
- if (dbmfp == NULL && mfp->lsn_off == -1)
+ if (LF_ISSET(DB_SYNC_QUEUE_EXTENT) &&
+ !F_ISSET(mfp, MP_EXTENT))
+ continue;
+
+ /*
+ * If we're flushing a specific file, see if
+ * this page is from that file.
+ */
+ if (dbmfp != NULL && mfp != dbmfp->mfp)
continue;
/* Track the buffer, we want it. */
@@ -343,10 +381,25 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
ar_max *= 2;
}
}
+ DB_ASSERT(dbenv, dirty == hp->hash_page_dirty);
+ if (dirty != hp->hash_page_dirty) {
+ __db_errx(dbenv,
+ "memp_sync: correcting dirty count %lu %lu",
+ (u_long)hp->hash_page_dirty, (u_long)dirty);
+ hp->hash_page_dirty = dirty;
+ }
MUTEX_UNLOCK(dbenv, hp->mtx_hash);
if (ret != 0)
goto err;
+
+ /* Check if the call has been interrupted. */
+ if (LF_ISSET(DB_SYNC_INTERRUPT_OK) && FLD_ISSET(
+ mp->config_flags, DB_MEMP_SYNC_INTERRUPT)) {
+ if (interruptedp != NULL)
+ *interruptedp = 1;
+ goto err;
+ }
}
}
@@ -366,7 +419,7 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
* If we're trickling buffers, only write enough to reach the correct
* percentage.
*/
- if (op == DB_SYNC_TRICKLE && ar_cnt > trickle_max)
+ if (LF_ISSET(DB_SYNC_TRICKLE) && ar_cnt > trickle_max)
ar_cnt = trickle_max;
/*
@@ -385,7 +438,7 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
* out its hash bucket pointer so we don't process a slot more than
* once.
*/
- for (i = pass = write_cnt = 0, remaining = ar_cnt; remaining > 0; ++i) {
+ for (i = pass = wrote_cnt = 0, remaining = ar_cnt; remaining > 0; ++i) {
if (i >= ar_cnt) {
i = 0;
++pass;
@@ -429,44 +482,40 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
*/
if (F_ISSET(bhp, BH_LOCKED) || (bhp->ref != 0 && pass < 2)) {
MUTEX_UNLOCK(dbenv, mutex);
- if (op != DB_SYNC_CACHE && op != DB_SYNC_FILE) {
+ if (!required_write) {
--remaining;
bharray[i].track_hp = NULL;
}
continue;
}
- /*
- * The buffer is dirty and may also be pinned.
- *
- * Set the sync wait-for count, used to count down outstanding
- * references to this buffer as they are returned to the cache.
- */
- bhp->ref_sync = bhp->ref;
-
/* Pin the buffer into memory and lock it. */
++bhp->ref;
F_SET(bhp, BH_LOCKED);
/*
- * Unlock the hash bucket and wait for the wait-for count to
- * go to 0. No new thread can acquire the buffer because we
- * have it locked.
+ * If the buffer is referenced by another thread, set the sync
+ * wait-for count (used to count down outstanding references to
+ * this buffer as they are returned to the cache), then unlock
+ * the hash bucket and wait for the count to go to 0. No other
+ * thread can acquire the buffer because we have it locked.
*
* If a thread attempts to re-pin a page, the wait-for count
- * will never go to 0 (the thread spins on our buffer lock,
+ * will never go to 0 (that thread spins on our buffer lock,
* while we spin on the thread's ref count). Give up if we
- * don't get the buffer in 3 seconds, we can try again later.
+ * don't get the buffer in 3 seconds, we'll try again later.
*
* If, when the wait-for count goes to 0, the buffer is found
* to be dirty, write it.
*/
- MUTEX_UNLOCK(dbenv, mutex);
- for (wait_cnt = 1;
- bhp->ref_sync != 0 && wait_cnt < 4; ++wait_cnt)
- __os_sleep(dbenv, 1, 0);
- MUTEX_LOCK(dbenv, mutex);
- hb_lock = 1;
+ bhp->ref_sync = bhp->ref - 1;
+ if (bhp->ref_sync != 0) {
+ MUTEX_UNLOCK(dbenv, mutex);
+ for (wait_cnt = 1;
+ bhp->ref_sync != 0 && wait_cnt < 4; ++wait_cnt)
+ __os_sleep(dbenv, 1, 0);
+ MUTEX_LOCK(dbenv, mutex);
+ }
/*
* If we've switched files, check to see if we're configured
@@ -476,7 +525,7 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
if (++filecnt >= maxopenfd) {
filecnt = 0;
if ((t_ret = __memp_close_flush_files(
- dbenv, dbmp, 1)) != 0 && ret == 0)
+ dbenv, 1)) != 0 && ret == 0)
ret = t_ret;
}
last_mf_offset = bhp->mf_offset;
@@ -496,28 +545,18 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
* dirty, we write it. We only try to write the buffer once.
*/
if (bhp->ref_sync == 0 && F_ISSET(bhp, BH_DIRTY)) {
- MUTEX_UNLOCK(dbenv, mutex);
- hb_lock = 0;
-
mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset);
if ((t_ret =
- __memp_bhwrite(dbmp, hp, mfp, bhp, 1)) == 0)
- ++wrote;
- else {
+ __memp_bhwrite(dbmp, hp, mfp, bhp, 1)) == 0) {
+ ++wrote_cnt;
+ ++wrote_total;
+ } else {
if (ret == 0)
ret = t_ret;
__db_errx
(dbenv, "%s: unable to flush page: %lu",
__memp_fns(dbmp, mfp), (u_long)bhp->pgno);
- }
- /*
- * Avoid saturating the disk, sleep once we've done
- * some number of writes.
- */
- if (maxwrite != 0 && ++write_cnt >= maxwrite) {
- write_cnt = 0;
- __os_sleep(dbenv, 0, (u_long)maxwrite_sleep);
}
}
@@ -525,18 +564,9 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
* If ref_sync count never went to 0, the buffer was written
* by another thread, or the write failed, we still have the
* buffer locked.
- *
- * We may or may not currently hold the hash bucket mutex. If
- * the __memp_bhwrite -> __memp_pgwrite call was successful,
- * __memp_pgwrite will have acquired the hash bucket lock; all
- * other call paths will leave us without the hash bucket lock.
*/
- if (F_ISSET(bhp, BH_LOCKED)) {
- if (!hb_lock)
- MUTEX_LOCK(dbenv, mutex);
-
+ if (F_ISSET(bhp, BH_LOCKED))
F_CLR(bhp, BH_LOCKED);
- }
/*
* Reset the ref_sync count regardless of our success, we're
@@ -548,7 +578,8 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
--bhp->ref;
/*
- * If a thread of control is waiting on this buffer, wake it up.
+ * If a thread of control is waiting in this hash bucket, wake
+ * it up.
*/
if (F_ISSET(hp, IO_WAITER)) {
F_CLR(hp, IO_WAITER);
@@ -557,29 +588,51 @@ __memp_sync_int(dbenv, dbmfp, trickle_max, op, wrotep)
/* Release the hash bucket mutex. */
MUTEX_UNLOCK(dbenv, mutex);
+
+ /* Check if the call has been interrupted. */
+ if (LF_ISSET(DB_SYNC_INTERRUPT_OK) &&
+ FLD_ISSET(mp->config_flags, DB_MEMP_SYNC_INTERRUPT)) {
+ if (interruptedp != NULL)
+ *interruptedp = 1;
+ goto err;
+ }
+
+ /*
+ * Sleep after some number of writes to avoid disk saturation.
+ * Don't cache the max writes value, an application shutting
+ * down might reset the value in order to do a fast flush or
+ * checkpoint.
+ */
+ if (!LF_ISSET(DB_SYNC_SUPPRESS_WRITE) &&
+ !FLD_ISSET(mp->config_flags, DB_MEMP_SUPPRESS_WRITE) &&
+ mp->mp_maxwrite != 0 && wrote_cnt >= mp->mp_maxwrite) {
+ wrote_cnt = 0;
+ __os_sleep(
+ dbenv, 0, (u_long)mp->mp_maxwrite_sleep);
+ }
}
done: /*
- * If doing a checkpoint or flushing a file for the application, we
- * have to force the pages to disk. We don't do this as we go along
- * because we want to give the OS as much time as possible to lazily
- * flush, and because we have to flush files that might not even have
- * had dirty buffers in the cache, so we have to walk the files list.
+ * If a write is required, we have to force the pages to disk. We
+ * don't do this as we go along because we want to give the OS as
+ * much time as possible to lazily flush, and because we have to flush
+ * files that might not even have had dirty buffers in the cache, so
+ * we have to walk the files list.
*/
- if (ret == 0 && (op == DB_SYNC_CACHE || op == DB_SYNC_FILE)) {
+ if (ret == 0 && required_write) {
if (dbmfp == NULL)
- ret = __memp_sync_files(dbenv, dbmp);
+ ret = __memp_sync_files(dbenv);
else
ret = __os_fsync(dbenv, dbmfp->fhp);
}
/* If we've opened files to flush pages, close them. */
- if ((t_ret = __memp_close_flush_files(dbenv, dbmp, 0)) != 0 && ret == 0)
+ if ((t_ret = __memp_close_flush_files(dbenv, 0)) != 0 && ret == 0)
ret = t_ret;
err: __os_free(dbenv, bharray);
- if (wrotep != NULL)
- *wrotep = wrote;
+ if (wrote_totalp != NULL)
+ *wrote_totalp = wrote_total;
return (ret);
}
@@ -651,28 +704,23 @@ __memp_sync_file(dbenv, mfp, argp, countp, flags)
/* If we don't find a handle we can use, open one. */
if (dbmfp == NULL) {
- if ((ret = __memp_mf_sync(dbmp, mfp, 0)) != 0) {
+ if ((ret = __memp_mf_sync(dbmp, mfp, 1)) != 0) {
__db_err(dbenv, ret,
"%s: unable to flush", (char *)
R_ADDR(dbmp->reginfo, mfp->path_off));
}
- } else {
+ } else
ret = __os_fsync(dbenv, dbmfp->fhp);
- if ((t_ret = __memp_fclose(dbmfp, 0)) != 0 && ret == 0)
- ret = t_ret;
- }
-
/*
* Re-acquire the MPOOLFILE mutex, we need it to modify the
* reference count.
*/
MUTEX_LOCK(dbenv, mfp->mutex);
- --mfp->mpf_cnt;
/*
- * If we wrote the file and there are no open handles (or there
- * is a single open handle, and it's the one we opened to write
+ * If we wrote the file and there are no other references (or there
+ * is a single reference, and it's the one we opened to write
* buffers during checkpoint), clear the file_written flag. We
* do this so that applications opening thousands of files don't
* loop here opening and flushing those files during checkpoint.
@@ -684,7 +732,7 @@ __memp_sync_file(dbenv, mfp, argp, countp, flags)
* the region lock, no possibility of another thread of control
* racing with us to open a MPOOLFILE.
*/
- if (mfp->mpf_cnt == 0 || (mfp->mpf_cnt == 1 &&
+ if (mfp->mpf_cnt == 1 || (mfp->mpf_cnt == 2 &&
dbmfp != NULL && F_ISSET(dbmfp, MP_FLUSH))) {
mfp->file_written = 0;
@@ -696,31 +744,44 @@ __memp_sync_file(dbenv, mfp, argp, countp, flags)
* I mean, what are the chances that there aren't any
* buffers in the pool? Regardless, it might happen.)
*/
- if (mfp->mpf_cnt == 0 && mfp->block_cnt == 0)
+ if (mfp->mpf_cnt == 1 && mfp->block_cnt == 0)
*(int *)argp = 1;
}
- /* Unlock the MPOOLFILE, and move to the next entry. */
+ /*
+ * If we found the file we must close it in case we are the last
+ * reference to the dbmfp. NOTE: since we have incremented
+ * mfp->mpf_cnt this cannot be the last reference to the mfp.
+ * This is important since we are called with the hash bucket
+ * locked. The mfp will get freed via the cleanup pass.
+ */
+ if (dbmfp != NULL && (t_ret = __memp_fclose(dbmfp, 0)) != 0 && ret == 0)
+ ret = t_ret;
+
+ --mfp->mpf_cnt;
+
+ /* Unlock the MPOOLFILE. */
MUTEX_UNLOCK(dbenv, mfp->mutex);
- return (0);
+ return (ret);
}
/*
* __memp_sync_files --
* Sync all the files in the environment, open or not.
*/
-static
-int __memp_sync_files(dbenv, dbmp)
+static int
+__memp_sync_files(dbenv)
DB_ENV *dbenv;
- DB_MPOOL *dbmp;
{
+ DB_MPOOL *dbmp;
DB_MPOOL_HASH *hp;
MPOOL *mp;
MPOOLFILE *mfp, *next_mfp;
int i, need_discard_pass, ret;
- need_discard_pass = ret = 0;
+ dbmp = dbenv->mp_handle;
mp = dbmp->reginfo[0].primary;
+ need_discard_pass = ret = 0;
ret = __memp_walk_files(dbenv,
mp, __memp_sync_file, &need_discard_pass, 0, DB_STAT_NOERROR);
@@ -734,7 +795,7 @@ int __memp_sync_files(dbenv, dbmp)
hp = R_ADDR(dbmp->reginfo, mp->ftab);
for (i = 0; i < MPOOL_FILE_BUCKETS; i++, hp++) {
- MUTEX_LOCK(dbenv, hp->mtx_hash);
+retry: MUTEX_LOCK(dbenv, hp->mtx_hash);
for (mfp = SH_TAILQ_FIRST(&hp->hash_bucket,
__mpoolfile); mfp != NULL; mfp = next_mfp) {
next_mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile);
@@ -743,13 +804,17 @@ int __memp_sync_files(dbenv, dbmp)
* without a mutex on the MPOOLFILE. If likely to
* succeed, lock the MPOOLFILE down and look for real.
*/
- if (mfp->block_cnt != 0 || mfp->mpf_cnt != 0)
+ if (mfp->deadfile ||
+ mfp->block_cnt != 0 || mfp->mpf_cnt != 0)
continue;
MUTEX_LOCK(dbenv, mfp->mutex);
- if (mfp->block_cnt == 0 && mfp->mpf_cnt == 0)
+ if (!mfp->deadfile &&
+ mfp->block_cnt == 0 && mfp->mpf_cnt == 0) {
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
(void)__memp_mf_discard(dbmp, mfp);
- else
+ goto retry;
+ } else
MUTEX_UNLOCK(dbenv, mfp->mutex);
}
MUTEX_UNLOCK(dbenv, hp->mtx_hash);
@@ -764,28 +829,36 @@ int __memp_sync_files(dbenv, dbmp)
* PUBLIC: int __memp_mf_sync __P((DB_MPOOL *, MPOOLFILE *, int));
*/
int
-__memp_mf_sync(dbmp, mfp, region_locked)
+__memp_mf_sync(dbmp, mfp, locked)
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
- int region_locked;
+ int locked;
{
DB_ENV *dbenv;
DB_FH *fhp;
+ DB_MPOOL_HASH *hp;
+ MPOOL *mp;
int ret, t_ret;
char *rpath;
+ COMPQUIET(hp, NULL);
dbenv = dbmp->dbenv;
/*
- * We need to be holding the region lock: we're using the path name
+ * We need to be holding the hash lock: we're using the path name
* and __memp_nameop might try and rename the file.
*/
- if (!region_locked)
- MPOOL_SYSTEM_LOCK(dbenv);
+ if (!locked) {
+ mp = dbmp->reginfo[0].primary;
+ hp = R_ADDR(dbmp->reginfo, mp->ftab);
+ hp += FNBUCKET(
+ R_ADDR(dbmp->reginfo, mfp->fileid_off), DB_FILE_ID_LEN);
+ MUTEX_LOCK(dbenv, hp->mtx_hash);
+ }
if ((ret = __db_appname(dbenv, DB_APP_DATA,
R_ADDR(dbmp->reginfo, mfp->path_off), 0, NULL, &rpath)) == 0) {
- if ((ret = __os_open(dbenv, rpath, 0, 0, &fhp)) == 0) {
+ if ((ret = __os_open(dbenv, rpath, 0, 0, 0, &fhp)) == 0) {
ret = __os_fsync(dbenv, fhp);
if ((t_ret =
__os_closehandle(dbenv, fhp)) != 0 && ret == 0)
@@ -794,8 +867,8 @@ __memp_mf_sync(dbmp, mfp, region_locked)
__os_free(dbenv, rpath);
}
- if (!region_locked)
- MPOOL_SYSTEM_UNLOCK(dbenv);
+ if (!locked)
+ MUTEX_UNLOCK(dbenv, hp->mtx_hash);
return (ret);
}
@@ -805,15 +878,17 @@ __memp_mf_sync(dbmp, mfp, region_locked)
* Close files opened only to flush buffers.
*/
static int
-__memp_close_flush_files(dbenv, dbmp, dosync)
+__memp_close_flush_files(dbenv, dosync)
DB_ENV *dbenv;
- DB_MPOOL *dbmp;
int dosync;
{
+ DB_MPOOL *dbmp;
DB_MPOOLFILE *dbmfp;
MPOOLFILE *mfp;
int ret;
+ dbmp = dbenv->mp_handle;
+
/*
* The routine exists because we must close files opened by sync to
* flush buffers. There are two cases: first, extent files have to
diff --git a/db/mp/mp_trickle.c b/db/mp/mp_trickle.c
index d1d3853aa..cbe7af4f2 100644
--- a/db/mp/mp_trickle.c
+++ b/db/mp/mp_trickle.c
@@ -1,10 +1,9 @@
/*-
* See the file LICENSE for redistribution information.
*
- * Copyright (c) 1996-2006
- * Oracle Corporation. All rights reserved.
+ * Copyright (c) 1996,2007 Oracle. All rights reserved.
*
- * $Id: mp_trickle.c,v 12.9 2006/08/24 14:46:15 bostic Exp $
+ * $Id: mp_trickle.c,v 12.16 2007/06/01 18:32:44 bostic Exp $
*/
#include "db_config.h"
@@ -89,15 +88,21 @@ __memp_trickle(dbenv, pct, nwrotep)
if (total == 0 || dirty == 0)
return (0);
- clean = total - dirty;
+ /*
+ * The total number of pages is an exact number, but the dirty page
+ * count can change while we're walking the hash buckets, and it's
+ * even possible the dirty page count ends up larger than the total
+ * number of pages.
+ */
+ clean = total > dirty ? total - dirty : 0;
need_clean = (total * (u_int)pct) / 100;
if (clean >= need_clean)
return (0);
need_clean -= clean;
- ret = __memp_sync_int(
- dbenv, NULL, need_clean, DB_SYNC_TRICKLE, &wrote);
- mp->stat.st_page_trickle += wrote;
+ ret = __memp_sync_int(dbenv, NULL,
+ need_clean, DB_SYNC_TRICKLE | DB_SYNC_INTERRUPT_OK, &wrote, NULL);
+ STAT((mp->stat.st_page_trickle += wrote));
if (nwrotep != NULL)
*nwrotep = (int)wrote;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 21:37:47 +0000