mirror of
https://github.com/berkeleydb/libdb.git
synced 2024-11-16 09:06:25 +00:00
674 lines
25 KiB
Tcl
674 lines
25 KiB
Tcl
# See the file LICENSE for redistribution information.
|
|
#
|
|
# Copyright (c) 2009, 2012 Oracle and/or its affiliates. All rights reserved.
|
|
#
|
|
# $Id$
|
|
#
|
|
# TEST env017
|
|
# TEST Check documented "stat" fields against the fields
|
|
# TEST returned by the "stat" functions. Make sure they
|
|
# TEST match, and that none are missing.
|
|
# TEST These are the stat functions we test:
|
|
# TEST env log_stat
|
|
# TEST env lock_stat
|
|
# TEST env txn_stat
|
|
# TEST env mutex_stat
|
|
# TEST env rep_stat
|
|
# TEST env repmgr_stat
|
|
# TEST env mpool_stat
|
|
# TEST db stat
|
|
# TEST seq stat
|
|
# TEST db compact_stat
|
|
|
|
|
|
proc env017 { } {
|
|
puts "\nEnv017: Check the integrity of the various stat"
|
|
env017_log_stat
|
|
env017_lock_stat
|
|
env017_txn_stat
|
|
env017_mutex_stat
|
|
env017_rep_stat
|
|
env017_repmgr_stat
|
|
env017_mpool_stat
|
|
env017_db_stat
|
|
env017_seq_stat
|
|
env017_compact_stat
|
|
}
|
|
|
|
# Check the log stat field.
|
|
proc env017_log_stat { } {
|
|
puts "\nEnv017: Check the Log stat field"
|
|
set check_type log_stat_check
|
|
set stat_method log_stat
|
|
set envargs {-create -log}
|
|
set map_list {
|
|
{ "Magic" st_magic }
|
|
{ "Log file Version" st_version }
|
|
{ "Region size" st_regsize }
|
|
{ "Log file mode" st_mode }
|
|
{ "Log record cache size" st_lg_bsize }
|
|
{ "Current log file size" st_lg_size }
|
|
{ "Initial fileid allocation" st_fileid_init }
|
|
{ "Current fileids in use" st_nfileid }
|
|
{ "Maximum fileids ever used" st_maxnfileid }
|
|
{ "Log file records written" st_record }
|
|
{ "Mbytes written" st_w_mbytes }
|
|
{ "Bytes written (over Mb)" st_w_bytes }
|
|
{ "Mbytes written since checkpoint" st_wc_mbytes }
|
|
{ "Bytes written (over Mb) since checkpoint"
|
|
st_wc_bytes }
|
|
{ "Times log written" st_wcount }
|
|
{ "Times log written because cache filled up"
|
|
st_wcount_fill }
|
|
{ "Times log read from disk" st_rcount }
|
|
{ "Times log flushed to disk" st_scount }
|
|
{ "Current log file number" st_cur_file }
|
|
{ "Current log file offset" st_cur_offset }
|
|
{ "On-disk log file number" st_disk_file }
|
|
{ "On-disk log file offset" st_disk_offset }
|
|
{ "Max commits in a log flush" st_maxcommitperflush }
|
|
{ "Min commits in a log flush" st_mincommitperflush }
|
|
{ "Number of region lock waits" st_region_wait }
|
|
{ "Number of region lock nowaits" st_region_nowait }
|
|
}
|
|
set doc_list [list st_magic st_version st_mode st_lg_bsize st_lg_size \
|
|
st_fileid_init st_nfileid st_maxnfileid \
|
|
st_record st_w_mbytes st_w_bytes st_wc_mbytes st_wc_bytes \
|
|
st_wcount st_wcount_fill st_rcount st_scount st_cur_file \
|
|
st_cur_offset st_disk_file st_disk_offset st_maxcommitperflush \
|
|
st_mincommitperflush st_regsize st_region_wait st_region_nowait ]
|
|
env017_stat_check \
|
|
$map_list $doc_list $check_type $stat_method $envargs
|
|
}
|
|
|
|
# Check the lock stat field.
|
|
proc env017_lock_stat { } {
|
|
puts "\nEnv017: Check the lock stat field"
|
|
set check_type lock_stat_check
|
|
set stat_method lock_stat
|
|
set envargs {-create -lock}
|
|
set map_list {
|
|
{ "Region size" st_regsize }
|
|
{ "Last allocated locker ID" st_id }
|
|
{ "Current maximum unused locker ID" st_cur_maxid }
|
|
{ "Initial locks" st_initlocks }
|
|
{ "Allocated locks" st_locks }
|
|
{ "Maximum locks" st_maxlocks }
|
|
{ "Initial lockers" st_initlockers }
|
|
{ "Allocated lockers" st_lockers }
|
|
{ "Maximum lockers" st_maxlockers }
|
|
{ "Initial objects" st_initobjects }
|
|
{ "Allocated objects" st_objects }
|
|
{ "Maximum objects" st_maxobjects }
|
|
{ "Lock modes" st_nmodes }
|
|
{ "Number of lock table partitions" st_partitions }
|
|
{ "Size of object hash table" st_tablesize }
|
|
{ "Current number of locks" st_nlocks }
|
|
{ "Maximum number of locks so far" st_maxnlocks }
|
|
{ "Maximum number of locks in any hash bucket"
|
|
st_maxhlocks }
|
|
{ "Maximum number of lock steals for an empty partition"
|
|
st_locksteals }
|
|
{ "Maximum number lock steals in any partition"
|
|
st_maxlsteals }
|
|
{ "Current number of lockers" st_nlockers }
|
|
{ "Maximum number of lockers so far" st_maxnlockers }
|
|
{ "Current number of objects" st_nobjects }
|
|
{ "Maximum number of objects so far" st_maxnobjects }
|
|
{ "Maximum number of objects in any hash bucket"
|
|
st_maxhobjects }
|
|
{ "Maximum number of object steals for an empty partition"
|
|
st_objectsteals }
|
|
{ "Maximum number object steals in any partition"
|
|
st_maxosteals }
|
|
{ "Lock requests" st_nrequests }
|
|
{ "Lock releases" st_nreleases }
|
|
{ "Lock upgrades" st_nupgrade }
|
|
{ "Lock downgrades" st_ndowngrade }
|
|
{ "Number of conflicted locks for which we waited"
|
|
st_lock_wait }
|
|
{ "Number of conflicted locks for which we did not wait"
|
|
st_lock_nowait }
|
|
{ "Deadlocks detected" st_ndeadlocks }
|
|
{ "Number of region lock waits" st_region_wait }
|
|
{ "Number of region lock nowaits" st_region_nowait }
|
|
{ "Number of object allocation waits" st_objs_wait }
|
|
{ "Number of object allocation nowaits" st_objs_nowait }
|
|
{ "Number of locker allocation waits" st_lockers_wait }
|
|
{ "Number of locker allocation nowaits" st_lockers_nowait }
|
|
{ "Maximum hash bucket length" st_hash_len }
|
|
{ "Lock timeout value" st_locktimeout }
|
|
{ "Number of lock timeouts" st_nlocktimeouts }
|
|
{ "Transaction timeout value" st_txntimeout }
|
|
{ "Number of transaction timeouts" st_ntxntimeouts }
|
|
{ "Number lock partition mutex waits" st_part_wait }
|
|
{ "Number lock partition mutex nowaits" st_part_nowait }
|
|
{ "Maximum number waits on any lock partition mutex"
|
|
st_part_max_wait }
|
|
{ "Maximum number nowaits on any lock partition mutex"
|
|
st_part_max_nowait }
|
|
}
|
|
set doc_list [list st_id st_cur_maxid st_nmodes \
|
|
st_initlocks st_initlockers st_initobjects \
|
|
st_locks st_lockers st_objects \
|
|
st_maxlocks st_maxlockers st_maxobjects \
|
|
st_partitions st_tablesize st_nlocks st_maxnlocks \
|
|
st_maxhlocks st_locksteals st_maxlsteals st_nlockers \
|
|
st_maxnlockers st_nobjects st_maxnobjects st_maxhobjects \
|
|
st_objectsteals st_maxosteals st_nrequests st_nreleases st_nupgrade\
|
|
st_ndowngrade st_lock_wait st_lock_nowait st_ndeadlocks \
|
|
st_locktimeout st_nlocktimeouts st_txntimeout st_ntxntimeouts \
|
|
st_objs_wait st_objs_nowait st_lockers_wait st_lockers_nowait \
|
|
st_hash_len st_regsize st_part_wait st_part_nowait st_part_max_wait\
|
|
st_part_max_nowait st_region_wait st_region_nowait]
|
|
env017_stat_check \
|
|
$map_list $doc_list $check_type $stat_method $envargs
|
|
}
|
|
|
|
# Check the txn stat field.
|
|
proc env017_txn_stat { } {
|
|
puts "\nEnv017: Check the transaction stat field"
|
|
set check_type txn_stat_check
|
|
set stat_method txn_stat
|
|
set envargs {-create -txn}
|
|
set map_list {
|
|
{ "Region size" st_regsize }
|
|
{ "LSN of last checkpoint" st_last_ckp }
|
|
{ "Time of last checkpoint" st_time_ckp }
|
|
{ "Last txn ID allocated" st_last_txnid }
|
|
{ "Maximum txns" st_maxtxns }
|
|
{ "Initial txns" st_inittxns }
|
|
{ "Number aborted txns" st_naborts }
|
|
{ "Number txns begun" st_nbegins }
|
|
{ "Number committed txns" st_ncommits }
|
|
{ "Number active txns" st_nactive }
|
|
{ "Number of snapshot txns" st_nsnapshot }
|
|
{ "Number restored txns" st_nrestores }
|
|
{ "Maximum active txns" st_maxnactive }
|
|
{ "Maximum snapshot txns" st_maxnsnapshot }
|
|
{ "Number of region lock waits" st_region_wait }
|
|
{ "Number of region lock nowaits" st_region_nowait }
|
|
}
|
|
set doc_list [list st_last_ckp st_time_ckp st_last_txnid st_maxtxns \
|
|
st_inittxns st_nactive st_nsnapshot st_maxnactive st_maxnsnapshot \
|
|
st_nbegins st_naborts st_ncommits st_nrestores st_regsize \
|
|
st_region_wait st_region_nowait ]
|
|
env017_stat_check \
|
|
$map_list $doc_list $check_type $stat_method $envargs
|
|
}
|
|
|
|
#Check the mutex stat field.
|
|
proc env017_mutex_stat { } {
|
|
puts "\nEnv017: Check the mutex stat field"
|
|
set check_type mutex_stat_check
|
|
set stat_method mutex_stat
|
|
set envargs {-create}
|
|
set map_list {
|
|
{ "Mutex align" st_mutex_align }
|
|
{ "Mutex TAS spins" st_mutex_tas_spins }
|
|
{ "Initial mutex count" st_mutex_init }
|
|
{ "Mutex count" st_mutex_cnt }
|
|
{ "Mutex max" st_mutex_max }
|
|
{ "Free mutexes" st_mutex_free }
|
|
{ "Mutexes in use" st_mutex_inuse }
|
|
{ "Max in use" st_mutex_inuse_max }
|
|
{ "Mutex region size" st_regsize }
|
|
{ "Mutex region max" st_regmax }
|
|
{ "Number of region waits" st_region_wait }
|
|
{ "Number of region no waits" st_region_nowait }
|
|
}
|
|
set doc_list [list st_mutex_align st_mutex_tas_spins st_mutex_init \
|
|
st_mutex_cnt st_mutex_max st_mutex_free st_mutex_inuse \
|
|
st_mutex_inuse_max st_regsize st_regmax st_region_wait \
|
|
st_region_nowait ]
|
|
|
|
env017_stat_check \
|
|
$map_list $doc_list $check_type $stat_method $envargs
|
|
}
|
|
|
|
# Check the rep stat field.
|
|
proc env017_rep_stat { } {
|
|
puts "\nEnv017: Check the replication stat field"
|
|
set check_type rep_stat_check
|
|
set stat_method rep_stat
|
|
set envargs {-create -rep -log -txn}
|
|
set map_list {
|
|
{ "Role" st_status}
|
|
{ "Next LSN expected" st_next_lsn }
|
|
{ "First missed LSN" st_waiting_lsn }
|
|
{ "Maximum permanent LSN" st_max_perm_lsn }
|
|
{ "Bulk buffer fills" st_bulk_fills }
|
|
{ "Bulk buffer overflows" st_bulk_overflows }
|
|
{ "Bulk records stored" st_bulk_records }
|
|
{ "Bulk buffer transfers" st_bulk_transfers }
|
|
{ "Client service requests" st_client_svc_req }
|
|
{ "Client service req misses" st_client_svc_miss }
|
|
{ "Client rerequests" st_client_rerequests }
|
|
{ "Duplicate master conditions" st_dupmasters }
|
|
{ "Environment ID" st_env_id }
|
|
{ "Environment priority" st_env_priority }
|
|
{ "Generation number" st_gen }
|
|
{ "Election generation number" st_egen }
|
|
{ "Startup complete" st_startup_complete }
|
|
{ "Lease messages sent" st_lease_sends }
|
|
{ "Lease checks" st_lease_chk }
|
|
{ "Lease check invalid" st_lease_chk_misses }
|
|
{ "Lease check refresh" st_lease_chk_refresh }
|
|
{ "Duplicate log records received" st_log_duplicated }
|
|
{ "Current log records queued" st_log_queued }
|
|
{ "Maximum log records queued" st_log_queued_max }
|
|
{ "Total log records queued" st_log_queued_total }
|
|
{ "Log records received" st_log_records }
|
|
{ "Log records requested" st_log_requested }
|
|
{ "Master environment ID" st_master }
|
|
{ "Master changes" st_master_changes }
|
|
{ "Messages with bad generation number" st_msgs_badgen }
|
|
{ "Messages processed" st_msgs_processed }
|
|
{ "Messages ignored for recovery" st_msgs_recover }
|
|
{ "Message send failures" st_msgs_send_failures }
|
|
{ "Messages sent" st_msgs_sent }
|
|
{ "New site messages" st_newsites }
|
|
{ "Number of sites in replication group" st_nsites }
|
|
{ "Transmission limited" st_nthrottles }
|
|
{ "Outdated conditions" st_outdated }
|
|
{ "Transactions applied" st_txns_applied }
|
|
{ "Next page expected" st_next_pg }
|
|
{ "First missed page" st_waiting_pg }
|
|
{ "Duplicate pages received" st_pg_duplicated }
|
|
{ "Pages received" st_pg_records }
|
|
{ "Pages requested" st_pg_requested }
|
|
{ "Elections held" st_elections }
|
|
{ "Elections won" st_elections_won }
|
|
{ "Election phase" st_election_status }
|
|
{ "Election winner" st_election_cur_winner }
|
|
{ "Election winner generation number" st_election_gen }
|
|
{ "Election data generation number" st_election_datagen }
|
|
{ "Election max LSN" st_election_lsn }
|
|
{ "Election sites" st_election_nsites }
|
|
{ "Election nvotes" st_election_nvotes }
|
|
{ "Election priority" st_election_priority }
|
|
{ "Election tiebreaker" st_election_tiebreaker }
|
|
{ "Election votes" st_election_votes }
|
|
{ "Election seconds" st_election_sec }
|
|
{ "Election usecs" st_election_usec }
|
|
{ "Start-sync operations delayed"
|
|
st_startsync_delayed }
|
|
{ "Maximum lease seconds" st_max_lease_sec }
|
|
{ "Maximum lease usecs" st_max_lease_usec }
|
|
{ "File fail cleanups done" st_filefail_cleanups }
|
|
}
|
|
set doc_list [list st_bulk_fills st_bulk_overflows st_bulk_records \
|
|
st_bulk_transfers st_client_rerequests st_client_svc_miss \
|
|
st_client_svc_req st_dupmasters st_egen st_election_cur_winner \
|
|
st_election_gen st_election_datagen st_election_lsn st_election_nsites \
|
|
st_election_nvotes st_election_priority st_election_sec \
|
|
st_election_status st_election_tiebreaker st_election_usec \
|
|
st_election_votes st_elections st_elections_won st_env_id \
|
|
st_env_priority st_filefail_cleanups st_gen st_lease_sends \
|
|
st_lease_chk st_lease_chk_misses st_lease_chk_refresh \
|
|
st_log_duplicated \
|
|
st_log_queued st_log_queued_max st_log_queued_total st_log_records \
|
|
st_log_requested st_master st_master_changes st_max_lease_sec \
|
|
st_max_lease_usec st_max_perm_lsn st_msgs_badgen st_msgs_processed\
|
|
st_msgs_recover st_msgs_send_failures st_msgs_sent st_newsites \
|
|
st_next_lsn st_next_pg st_nsites st_nthrottles st_outdated \
|
|
st_pg_duplicated st_pg_records st_pg_requested \
|
|
st_startsync_delayed st_startup_complete st_status st_txns_applied\
|
|
st_waiting_lsn st_waiting_pg ]
|
|
env017_stat_check \
|
|
$map_list $doc_list $check_type $stat_method $envargs
|
|
}
|
|
|
|
# Check the repmgr stat field.
|
|
proc env017_repmgr_stat { } {
|
|
puts "\nEnv017: Check the repmgr stat field"
|
|
set check_type repmgr_stat_check
|
|
set stat_method repmgr_stat
|
|
set envargs {-create -txn -rep}
|
|
set map_list {
|
|
{ "Acknowledgement failures" st_perm_failed }
|
|
{ "Messages delayed" st_msgs_queued}
|
|
{ "Messages discarded" st_msgs_dropped}
|
|
{ "Connections dropped" st_connection_drop}
|
|
{ "Failed re-connects" st_connect_fail}
|
|
{ "Election threads" st_elect_threads}
|
|
{ "Max elect threads" st_max_elect_threads}
|
|
}
|
|
set doc_list [list st_perm_failed st_msgs_queued st_msgs_dropped \
|
|
st_connection_drop st_connect_fail st_elect_threads \
|
|
st_max_elect_threads ]
|
|
env017_stat_check \
|
|
$map_list $doc_list $check_type $stat_method $envargs
|
|
}
|
|
|
|
# Check the mpool stat field.
|
|
proc env017_mpool_stat { } {
|
|
puts "\nEnv017: Check the mpool stat field"
|
|
set check_type mpool_stat_check
|
|
set stat_method mpool_stat
|
|
set envargs {-create}
|
|
set map_list {
|
|
{ "Cache size (gbytes)" st_gbytes }
|
|
{ "Cache size (bytes)" st_bytes }
|
|
{ "Number of caches" st_ncache }
|
|
{ "Maximum number of caches" st_max_ncache }
|
|
{ "Region size" st_regsize }
|
|
{ "Region max" st_regmax }
|
|
{ "Maximum memory-mapped file size" st_mmapsize }
|
|
{ "Maximum open file descriptors" st_maxopenfd }
|
|
{ "Maximum sequential buffer writes" st_maxwrite }
|
|
{ "Sleep after writing maximum buffers" st_maxwrite_sleep }
|
|
{ "Pages mapped into address space" st_map }
|
|
{ "Cache hits" st_cache_hit }
|
|
{ "Cache misses" st_cache_miss }
|
|
{ "Pages created" st_page_create }
|
|
{ "Pages read in" st_page_in }
|
|
{ "Pages written" st_page_out }
|
|
{ "Clean page evictions" st_ro_evict }
|
|
{ "Dirty page evictions" st_rw_evict }
|
|
{ "Dirty pages trickled" st_page_trickle }
|
|
{ "Cached pages" st_pages }
|
|
{ "Cached clean pages" st_page_clean }
|
|
{ "Cached dirty pages" st_page_dirty }
|
|
{ "Hash buckets" st_hash_buckets }
|
|
{ "Mutexes for hash buckets" st_hash_mutexes }
|
|
{ "Default pagesize" st_pagesize }
|
|
{ "Hash lookups" st_hash_searches }
|
|
{ "Longest hash chain found" st_hash_longest }
|
|
{ "Hash elements examined" st_hash_examined }
|
|
{ "Number of hash bucket nowaits" st_hash_nowait }
|
|
{ "Number of hash bucket waits" st_hash_wait }
|
|
{ "Maximum number of hash bucket nowaits"
|
|
st_hash_max_nowait }
|
|
{ "Maximum number of hash bucket waits" st_hash_max_wait }
|
|
{ "Number of region lock nowaits" st_region_nowait }
|
|
{ "Number of region lock waits" st_region_wait }
|
|
{ "Buffers frozen" st_mvcc_frozen }
|
|
{ "Buffers thawed" st_mvcc_thawed }
|
|
{ "Frozen buffers freed" st_mvcc_freed }
|
|
{ "Page allocations" st_alloc }
|
|
{ "Buckets examined during allocation" st_alloc_buckets }
|
|
{ "Maximum buckets examined during allocation"
|
|
st_alloc_max_buckets }
|
|
{ "Pages examined during allocation" st_alloc_pages }
|
|
{ "Maximum pages examined during allocation"
|
|
st_alloc_max_pages }
|
|
{ "Threads waiting on buffer I/O" st_io_wait}
|
|
{ "Number of syncs interrupted" st_sync_interrupted}
|
|
}
|
|
set doc_list [list st_gbytes st_bytes st_ncache st_max_ncache \
|
|
st_regsize st_regmax st_mmapsize st_maxopenfd st_maxwrite \
|
|
st_maxwrite_sleep st_map st_cache_hit st_cache_miss \
|
|
st_page_create st_page_in st_page_out st_ro_evict st_rw_evict \
|
|
st_page_trickle st_pages st_page_clean st_page_dirty \
|
|
st_hash_buckets st_hash_mutexes st_pagesize st_hash_searches \
|
|
st_hash_longest st_hash_examined st_hash_nowait st_hash_wait \
|
|
st_hash_max_nowait st_hash_max_wait st_region_wait \
|
|
st_region_nowait st_mvcc_frozen st_mvcc_thawed st_mvcc_freed \
|
|
st_alloc st_alloc_buckets st_alloc_max_buckets st_alloc_pages \
|
|
st_alloc_max_pages st_io_wait st_sync_interrupted ]
|
|
env017_stat_check \
|
|
$map_list $doc_list $check_type $stat_method $envargs
|
|
}
|
|
|
|
# Check the db stat field.
|
|
proc env017_db_stat { } {
|
|
puts "\nEnv017: Check the db stat field"
|
|
set hash_map_list {
|
|
{ "Magic" hash_magic }
|
|
{ "Version" hash_version }
|
|
{ "Page size" hash_pagesize }
|
|
{ "Page count" hash_pagecnt }
|
|
{ "Number of keys" hash_nkeys }
|
|
{ "Number of records" hash_ndata }
|
|
{ "Fill factor" hash_ffactor }
|
|
{ "Buckets" hash_buckets }
|
|
{ "Free pages" hash_free }
|
|
{ "Bytes free" hash_bfree }
|
|
{ "Number of big pages" hash_bigpages }
|
|
{ "Big pages bytes free" hash_big_bfree }
|
|
{ "Overflow pages" hash_overflows }
|
|
{ "Overflow bytes free" hash_ovfl_free }
|
|
{ "Duplicate pages" hash_dup }
|
|
{ "Duplicate pages bytes free" hash_dup_free }
|
|
{ "Flags" flags }
|
|
}
|
|
set queue_map_list {
|
|
{ "Magic" qs_magic }
|
|
{ "Version" qs_version }
|
|
{ "Page size" qs_pagesize }
|
|
{ "Extent size" qs_extentsize }
|
|
{ "Number of keys" qs_nkeys }
|
|
{ "Number of records" qs_ndata }
|
|
{ "Record length" qs_re_len }
|
|
{ "Record pad" qs_re_pad }
|
|
{ "First record number" qs_first_recno }
|
|
{ "Last record number" qs_cur_recno }
|
|
{ "Number of pages" qs_pages }
|
|
{ "Bytes free" qs_pgfree}
|
|
{ "Flags" flags }
|
|
}
|
|
set btree_map_list {
|
|
{ "Magic" bt_magic }
|
|
{ "Version" bt_version }
|
|
{ "Number of keys" bt_nkeys }
|
|
{ "Number of records" bt_ndata }
|
|
{ "Minimum keys per page" bt_minkey }
|
|
{ "Fixed record length" bt_re_len }
|
|
{ "Record pad" bt_re_pad }
|
|
{ "Page size" bt_pagesize }
|
|
{ "Page count" bt_pagecnt }
|
|
{ "Levels" bt_levels }
|
|
{ "Internal pages" bt_int_pg }
|
|
{ "Leaf pages" bt_leaf_pg }
|
|
{ "Duplicate pages" bt_dup_pg }
|
|
{ "Overflow pages" bt_over_pg }
|
|
{ "Empty pages" bt_empty_pg }
|
|
{ "Pages on freelist" bt_free }
|
|
{ "Internal pages bytes free" bt_int_pgfree }
|
|
{ "Leaf pages bytes free" bt_leaf_pgfree }
|
|
{ "Duplicate pages bytes free" bt_dup_pgfree }
|
|
{ "Bytes free in overflow pages" bt_over_pgfree }
|
|
{ "Flags" flags }
|
|
}
|
|
set hash_doc_list [list hash_magic hash_version hash_nkeys hash_ndata \
|
|
hash_pagecnt hash_pagesize hash_ffactor hash_buckets hash_free \
|
|
hash_bfree hash_bigpages hash_big_bfree hash_overflows \
|
|
hash_ovfl_free hash_dup hash_dup_free flags]
|
|
|
|
set btree_doc_list [list bt_magic bt_version bt_nkeys bt_ndata \
|
|
bt_pagecnt bt_pagesize bt_minkey bt_re_len bt_re_pad bt_levels \
|
|
bt_int_pg bt_leaf_pg bt_dup_pg bt_over_pg bt_empty_pg bt_free \
|
|
bt_int_pgfree bt_leaf_pgfree bt_dup_pgfree bt_over_pgfree flags ]
|
|
|
|
set queue_doc_list [list qs_magic qs_version qs_nkeys qs_ndata \
|
|
qs_pagesize qs_extentsize qs_pages qs_re_len qs_re_pad qs_pgfree \
|
|
qs_first_recno qs_cur_recno flags ]
|
|
|
|
# Check the hash db stat field.
|
|
puts "\tEnv017: Check the hash db stat"
|
|
env017_dbstat_check \
|
|
$hash_map_list $hash_doc_list {hash_db_stat_check} {-create -hash}
|
|
|
|
# Check the queue db stat field.
|
|
puts "\tEnv017: Check the queue db stat"
|
|
env017_dbstat_check \
|
|
$queue_map_list $queue_doc_list {queue_db_stat_check} \
|
|
{-create -queue}
|
|
|
|
# Check the btree/recno db stat field.
|
|
puts "\tEnv017: Check the btree/recno db stat"
|
|
env017_dbstat_check \
|
|
$btree_map_list $btree_doc_list {btree_db_stat_check} \
|
|
{-create -btree}
|
|
}
|
|
|
|
|
|
# Check the sequence stat field.
|
|
proc env017_seq_stat { } {
|
|
puts "\nEnv017: Check the sequence stat field"
|
|
source ./include.tcl
|
|
env_cleanup $testdir
|
|
set file1 db1.db
|
|
set db1 [berkdb open -create -btree $testdir/$file1]
|
|
error_check_good is_valid_db [is_valid_db $db1] TRUE
|
|
set seq [berkdb sequence -create -min 0 -max 1024768 $db1 seq_key1]
|
|
error_check_good is_valid_seq [is_valid_seq $seq] TRUE
|
|
set stat_list [$seq stat]
|
|
set map_list {
|
|
{ "Wait" st_wait }
|
|
{ "No wait" st_nowait }
|
|
{ "Current" st_current }
|
|
{ "Cached" st_value }
|
|
{ "Max Cached" st_last_value }
|
|
{ "Min" st_min }
|
|
{ "Max" st_max }
|
|
{ "Cache size" st_cache_size}
|
|
{ "Flags" st_flags}
|
|
}
|
|
set doc_list [list st_wait st_nowait st_current st_value \
|
|
st_last_value st_min st_max st_cache_size st_flags]
|
|
env017_do_check $map_list $stat_list $doc_list {seq_stat}
|
|
error_check_good "$seq close" [$seq close] 0
|
|
error_check_good "$db1 close" [$db1 close] 0
|
|
}
|
|
|
|
# Check the compact stat field.
|
|
proc env017_compact_stat { } {
|
|
puts "\nEnv017: Check the compact stat field"
|
|
source ./include.tcl
|
|
env_cleanup $testdir
|
|
set file1 db1.db
|
|
set db1 [berkdb open -create -btree $testdir/$file1]
|
|
error_check_good is_valid_db [is_valid_db $db1] TRUE
|
|
set ret [catch {eval $db1 compact -freespace}]
|
|
error_check_good compact_ok $ret 0
|
|
set stat_list [$db1 compact_stat]
|
|
set map_list {
|
|
{ "Pages freed" compact_pages_free }
|
|
{ "Pages truncated" compact_pages_truncated }
|
|
{ "Pages examined" compact_pages_examine }
|
|
{ "Levels removed" compact_levels }
|
|
{ "Deadlocks encountered" compact_deadlock }
|
|
{ "Empty buckets" compact_empty_buckets }
|
|
}
|
|
set doc_list [list compact_pages_free compact_pages_truncated \
|
|
compact_pages_examine compact_levels compact_deadlock \
|
|
compact_empty_buckets]
|
|
env017_do_check $map_list $stat_list $doc_list {compact_stat}
|
|
error_check_good "$db1 close" [$db1 close] 0
|
|
}
|
|
|
|
# This is common proc for the stat method called by env handle.
|
|
proc env017_stat_check { map_list doc_list check_type stat_method \
|
|
{envargs {}} } {
|
|
source ./include.tcl
|
|
set extopts {
|
|
{""}
|
|
{"-thread"}
|
|
{"-private" {"mutex_stat" "requires.*mutex.*subsystem"}}
|
|
{"-thread -private"}
|
|
}
|
|
|
|
foreach extopt $extopts {
|
|
set extarg [lindex $extopt 0]
|
|
set failmsg ""
|
|
set fail 0
|
|
if {[llength $extopt] > 1} {
|
|
set len [llength $extopt]
|
|
for {set i 1} {$i < $len} {incr i} {
|
|
set item [lindex $extopt $i]
|
|
set stat [lindex $item 0]
|
|
if {$stat == $stat_method} {
|
|
set failmsg [lindex $item 1]
|
|
set fail 1
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
env_cleanup $testdir
|
|
puts "\tEnv017: Check DB_ENV->$stat_method ($envargs $extarg)"
|
|
set env [eval berkdb_env_noerr $extarg $envargs -home $testdir]
|
|
error_check_good is_valid_env [is_valid_env $env] TRUE
|
|
if {$fail == 0} {
|
|
set stat_list [$env $stat_method]
|
|
env017_do_check \
|
|
$map_list $stat_list $doc_list $check_type
|
|
} else {
|
|
set ret [catch {eval $env $stat_method} res]
|
|
error_check_bad $stat_method $ret 0
|
|
error_check_bad chk_err [regexp $failmsg $res] 0
|
|
}
|
|
error_check_good "$env close" [$env close] 0
|
|
}
|
|
}
|
|
|
|
# This is common proc for db stat.
|
|
proc env017_dbstat_check { map_list doc_list check_type {dbargs {}} } {
|
|
source ./include.tcl
|
|
env_cleanup $testdir
|
|
set filename "db1.db"
|
|
set db [eval berkdb_open_noerr $dbargs $testdir/$filename]
|
|
error_check_good is_valid_db [is_valid_db $db] TRUE
|
|
set stat_list [$db stat]
|
|
env017_do_check $map_list $stat_list $doc_list $check_type
|
|
error_check_good "$db close" [$db close] 0
|
|
}
|
|
|
|
# This proc does the actual checking job.
|
|
proc env017_do_check { map_list stat_list doc_list check_type } {
|
|
# Check if all the items in the stat_list have the corresponding
|
|
# item in doc_list.
|
|
foreach l $map_list {
|
|
set field_map([lindex $l 0]) [lindex $l 1]
|
|
}
|
|
puts "\tEnv017: Check from stat_list"
|
|
set res_stat_list {}
|
|
foreach item $stat_list {
|
|
puts "\t\tEnv017: Checking item [lindex $item 0]"
|
|
if {![info exists field_map([lindex $item 0])]} {
|
|
lappend res_stat_list [lindex $item 0]
|
|
continue
|
|
}
|
|
set cur_field $field_map([lindex $item 0])
|
|
if {[lsearch -exact $doc_list $cur_field] == -1} {
|
|
lappend res_stat_list [lindex $item 0]
|
|
}
|
|
}
|
|
if {[llength $res_stat_list]>0} {
|
|
puts -nonewline "FAIL: in stat_list of $check_type, "
|
|
puts "Mismatch Items: $res_stat_list"
|
|
}
|
|
|
|
# Check if all the items in the doc_list have the corresponding
|
|
# record in the stat_list.
|
|
foreach l $map_list {
|
|
set field_map([lindex $l 1]) [lindex $l 0]
|
|
}
|
|
|
|
set stat_field_list {}
|
|
|
|
foreach item $stat_list {
|
|
lappend stat_field_list [lindex $item 0]
|
|
}
|
|
|
|
set res_doc_list {}
|
|
puts "\tEnv017: Check from doc_list"
|
|
foreach item $doc_list {
|
|
puts "\t\tEnv017: Checking item [lindex $item 0]"
|
|
if {![info exists field_map([lindex $item 0])]} {
|
|
lappend res_doc_list [lindex $item 0]
|
|
continue
|
|
}
|
|
set cur_field $field_map([lindex $item 0])
|
|
if {[lsearch -exact $stat_field_list $cur_field] == -1} {
|
|
lappend res_doc_list [lindex $item 0]
|
|
}
|
|
}
|
|
if {[llength $res_doc_list]>0} {
|
|
puts -nonewline "FAIL: in doc_list of $check_type, "
|
|
puts "Mismatch Items: $res_doc_list"
|
|
}
|
|
}
|
|
|