gecko-dev/db/test/mpoolscript.tcl

188 строки
5.1 KiB
Tcl

# See the file LICENSE for redistribution information.
#
# Copyright (c) 1996, 1997, 1998
# Sleepycat Software. All rights reserved.
#
# @(#)mpoolscript.tcl 10.4 (Sleepycat) 4/10/98
#
# Random multiple process mpool tester.
# Usage: mpoolscript dir id numiters numfiles numpages sleepint seed
# dir: lock directory.
# id: Unique identifier for this process.
# maxprocs: Number of procs in this test.
# numiters: Total number of iterations.
# pgsizes: Pagesizes for the different files. Length of this item indicates
# how many files to use.
# numpages: Number of pages per file.
# sleepint: Maximum sleep interval.
# seed: Seed for random number generator. If -1, use pid.
# envopt: Environment options.
source ../test/testutils.tcl
source ./include.tcl
set usage \
"mpoolscript dir id maxprocs numiters pgsizes numpages sleepint seed envopts"
# Verify usage
if { $argc != 9 } {
puts stderr $usage
puts $argc
exit
}
# Initialize arguments
set dir [lindex $argv 0]
set id [lindex $argv 1]
set maxprocs [lindex $argv 2]
set numiters [ lindex $argv 3 ]
set pgsizes [ lindex $argv 4 ]
set numpages [ lindex $argv 5 ]
set sleepint [ lindex $argv 6 ]
set seed [ lindex $argv 7 ]
set envopts [ lindex $argv 8]
# Initialize seed
if { $seed == -1 } {
srand [pid]
} else {
srand $seed
}
puts -nonewline "Beginning execution for $id: $maxprocs $dir $numiters"
puts " $pgsizes $numpages $sleepint $seed"
flush stdout
# Figure out how small/large to make the cache
set max 0
foreach i $pgsizes {
if { $i > $max } {
set max $i
}
}
set cache [expr $maxprocs * ([lindex $pgsizes 0] + $max)]
set cmd {memp "" 0 0 -dbhome $dir -cachesize $cache}
set cmd [concat $cmd $envopts]
set mp [ eval $cmd]
error_check_bad memp $mp NULL
error_check_good memp [is_substr $mp mp] 1
# Now open files
set flist {}
set nfiles 0
foreach psize $pgsizes {
set mpf [$mp open file$nfiles $psize $DB_CREATE 0644]
error_check_bad memp_fopen:$nfiles $mpf NULL
error_check_good memp_fopen:$nfiles [is_substr $mpf $mp] 1
lappend flist $mpf
incr nfiles
}
# Now create the lock region
# We'll use the convention that we lock by fileid:pageno
set lp [lock_open "" 0 0 -dbhome $dir $envopts]
error_check_bad lock_open $lp NULL
error_check_good lock_open [is_substr $lp lockmgr] 1
puts "Establishing long-term pin on file 0 page $id for process $id"
# Set up the long-pin page
set lock [$lp get $id 0:$id $DB_LOCK_WRITE 0]
error_check_bad lock_get $lock NULL
error_check_good lock_get [is_substr $lock $lp] 1
set mpf [lindex $flist 0]
set master_page [$mpf get $id $DB_MPOOL_CREATE]
error_check_bad mp_get:$master_page $master_page NULL
error_check_good mp_get:$master_page [is_substr $master_page page] 1
set r [$master_page init MASTER$id]
error_check_good page_init $r 0
# Release the lock but keep the page pinned
set r [$lock put]
error_check_good lock_put $r 0
# Main loop. On each iteration, we'll check every page in each of
# of the files. On any file, if we see the appropriate tag in the
# field, we'll rewrite the page, else we won't. Keep track of
# how many pages we actually process.
set pages 0
for { set iter 0 } { $iter < $numiters } { incr iter } {
puts "[timestamp]: iteration $iter, $pages pages set so far"
flush stdout
for { set fnum 1 } { $fnum < $nfiles } { incr fnum } {
if { [expr $fnum % 2 ] == 0 } {
set pred [expr ($id + $maxprocs - 1) % $maxprocs]
} else {
set pred [expr ($id + $maxprocs + 1) % $maxprocs]
}
set mpf [lindex $flist $fnum]
for { set p 0 } { $p < $numpages } { incr p } {
set lock [$lp get $id $fnum:$p $DB_LOCK_WRITE 0]
error_check_bad lock_get:$fnum:$p $lock NULL
error_check_good lock_get:$fnum:$p \
[is_substr $lock $lp] 1
# Now, get the page
set pp [$mpf get $p $DB_MPOOL_CREATE]
error_check_bad page_get:$fnum:$p $pp NULL
error_check_good page_get:$fnum:$p \
[is_substr $pp page] 1
if { [$pp check $pred] == 0 || [$pp check nul] == 0 } {
# Set page to self.
set r [$pp init $id]
error_check_good page_init:$fnum:$p $r 0
incr pages
set r [$pp put $DB_MPOOL_DIRTY]
error_check_good page_put:$fnum:$p $r 0
} else {
error_check_good page_put:$fnum:$p [$pp put 0] 0
}
error_check_good lock_put:$fnum:$p [$lock put] 0
}
}
exec $SLEEP [random_int 1 $sleepint]
}
# Now verify your master page, release its pin, then verify everyone else's
puts "$id: End of run verification of master page"
set r [$master_page check MASTER$id]
error_check_good page_check $r 0
set r [$master_page put $DB_MPOOL_DIRTY]
error_check_good page_put $r 0
set i [expr ($id + 1) % $maxprocs]
set mpf [lindex $flist 0]
while { $i != $id } {
set p [ $mpf get $i $DB_MPOOL_CREATE ]
error_check_bad mp_get $p NULL
error_check_good mp_get [is_substr $p page] 1
if { [$p check MASTER$i] != 0 } {
puts "Warning: Master page $i not set."
}
error_check_good page_put:$p [$p put 0] 0
set i [expr ($i + 1) % $maxprocs]
}
# Close lock system
set r [$lp close]
error_check_good lock_close $r 0
# Close files
foreach i $flist {
set r [$i close]
error_check_good mpf_close $r 0
}
# Close mpool system
set r [$mp close]
error_check_good memp_close $r 0
puts "[timestamp] $id Complete"
flush stdout