ae: add comments and update estimated resources

This commit is contained in:
lidj 2023-09-04 17:12:34 +08:00
parent fab216f6bd
commit e408942bc0
37 changed files with 277 additions and 354 deletions

View File

@ -213,6 +213,21 @@ After all, run `./fig12.sh`.
3. copy logs of Aurora (by default, in `/aurora-data/`) to `artificial_evaluation/logs/<mode>/rocksdb/`
3. run `./fig14.sh`
## Estimated Resources
Space are consumed within the microkernel.
| Test | Estimated Time | Details |
| -------------------------------------- | ---------------------- | ---------- |
| 1/test_ckpt_details.sh | ~24 min | ~3 min per workload, 8 workloads | | |
| 1/test_ckpt_size.sh | ~18 min | ~3 min per workload, 6 workloads | | |
| 1/test_restore_details.sh | ~21 min | ~3 min per workload, 7 workloads |
| 2/test_*.sh | ~1 hour (~12 min * 5 configurations) | ~3 minutes per workload, 4 workloads, 5 configurations | |
| 3/test_base.sh + test_ext_syn.sh | ~9 min (ext-sync) + 12 min (base) | ~3 min per workload, 3 configurations (ext-sync) + 4 configurations (base) | |
| 4/test_memcached.sh | ~15 min | ~3 min per test, 5 configurations | |
| 5/test_ycsb.sh | ~32 min | ~4 min per test, 4 * 2 configurations |
| 6/test_rocksdb.sh | ~6 min | ~3 min per test, 2 configurations |
## Common Q&A
Q. Changing the CPU number

View File

@ -3,6 +3,8 @@
source ../config.sh
mkdir -p './result'
# draw fig9a and fig9b with logs in $logbasedir/ckpt-breakdown/
python draw_fig.py $logbasedir/ckpt-breakdown/ a
python draw_fig.py $logbasedir/ckpt-breakdown/ b
echo "fig9a and fig9b is saved in ./result"
echo "fig9a and fig9b is saved in ./result"

View File

View File

@ -3,8 +3,10 @@
source ../config.sh
mkdir -p './result'
# Object Composition (Count)
# object composition (count)
# data is printed and saved in "result/table2-counts.csv"
python break_down.py $logbasedir/ckpt-breakdown/ count
# Size (MB)
# size (MB)
# data is printed and saved in "result/table2-memsize.csv"
python parse_mem_size.py $logbasedir/ckpt-size/ './result/table2-mem-size.csv'

View File

@ -3,5 +3,10 @@
source ../config.sh
mkdir -p './result'
# incur and full checkpoint time
# data is printed and saved in "result/table3-full/incur-colum.csv"
python break_down.py $logbasedir/ckpt-breakdown/ ckpt
# restore time
# data is printed and saved in "result/table3-restore-column.csv"
python break_down_restore.py $logbasedir/restore-breakdown/ restore

View File

@ -3,4 +3,11 @@
source ../config.sh
mkdir -p './result'
# data is printed and saved in "result/table4.csv"
# data will have five rows:
# 1. # of runtime page faults
# 2. # of dirty cached pages
# 3. # of cached pages
# 4. Ratio of page faults eliminated
# 5. Dirty rate in cached pages
python break_down.py $logbasedir/ckpt-breakdown/ extra

View File

@ -6,12 +6,15 @@ logdir=$logbasedir/ckpt-breakdown
loop=(0)
mkdir -p $logdir
# Test each workloads with ckpt-log mode
# ckpt-log mode will take checkpoint with log reported while running
for workload in default memcached redis sqlite leveldb kmeans word_count pca
# run a subset of workload
# for workload in pca
# for workload in default
do
for run in ${loop[@]}
do
echo "Test ckpt details with workload: $workload"
if [ $workload == "redis" ]; then
$appdir/$workload.exp ckpt-log set nopipe 1 3 2>&1 | tee $logdir/$workload.ckpt1ms.log3.$run.log
else
@ -19,4 +22,4 @@ do
fi
sleep 5
done
done
done

View File

@ -6,10 +6,10 @@ set logdir $logbasedir/ckpt-size
set timeout 180
# set workloads {memcached redis sqlite leveldb kmeans word_count}
set workloads {memcached redis sqlite leveldb kmeans word_count}
spawn mkdir -p $logdir
# Test memory usage of each workload
foreach workload $workloads {
foreach flag {raw ckpt} {
foreach i {0} {

View File

@ -6,13 +6,15 @@ logdir=$logbasedir/restore-breakdown
loop=(0)
mkdir -p $logdir
# Test each workloads with restore-test mode
# restore-test mode will first take a checkpoint and then shutdown to restore
for workload in default word_count sqlite leveldb kmeans redis memcached
# run a subset of workload
# for workload in leveldb kmeans redis memcached
# for workload in default
do
for run in ${loop[@]}
do
# $appdir/$workload.exp "restore-log" 500 4 2>&1 | tee $logdir/$workload.restore.$run.log
echo "Test restore details with workload: $workload"
if [ $workload == "redis" ]; then
$appdir/$workload.exp restore-test set nopipe 1000 0 2>&1 | tee $logdir/$workload.restore.$run.log
elif [ $workload == "leveldb" ]; then

View File

@ -1,13 +1,15 @@
source ../config.exp
proc run_test {workload flag} {
set thread 8
if {$flag == "ckpt"} {
send -- "checkpoint.bin -i %10 -l 0 -a 14 &\r"
send -- "checkpoint.bin -i %10 -l 0 -a 9 &\r"
expect "Launching /checkpoint.bin"
puts "${workload}"
}
switch $workload {
"kmeans" {
send -- "kmeans.bin -p 500000 &\r"
send -- "kmeans.bin -p $kmeans_num &\r"
expect "KMeans: MapReduce Completed"
}
"word_count" {
@ -18,16 +20,16 @@ proc run_test {workload flag} {
puts "redis set test"
send -- "redis-server --save \"\" -h 127.0.0.1 &\r"
expect "poll fd server is not lwip"
send -- "redis-benchmark -t set -n 1000000 -d 1024 --threads $thread &\r"
send -- "redis-benchmark -t set -n $redis_num -d 1024 --threads $thread &\r"
expect "requests per second"
}
"memcached" {
send -- "memcached -l 127.0.0.1 -p 123 & \r"
send -- "memcached -l 127.0.0.1 -p 123 -t $thread & \r"
expect "poll fd server is not lwip"
send -- "memcachetest -h 127.0.0.1:123 -M 1024 -F -t $thread -i 1000000 &\r"
send -- "memcachetest -h 127.0.0.1:123 -M 1024 -F -t $thread -i $memcached_num &\r"
expect "Launching /memcachetest"
# expect "Total gets:"
expect "Total gets:"
expect "Total sets:"
}
"sqlite" {
@ -35,7 +37,7 @@ proc run_test {workload flag} {
expect "sqlite_test done"
}
"leveldb" {
send -- "leveldb-dbbench &\r"
send -- "leveldb-dbbench --benchmarks=fillbatch --num=$leveldb_num &\r"
expect "snappyuncomp"
expect "Min"
}

View File

@ -4,6 +4,8 @@ source ../config.sh
mkdir -p ./result
# parse logs and save data in "./result/hybrid-mem.csv"
python read_data.py $logbasedir/hybrid-mem
# draw fig10 with saved data
python draw_fig10.py ./result/hybrid-mem.csv
echo "fig10 is saved in ./result"

View File

@ -8,6 +8,8 @@ mode=$1
mkdir -p $logdir
# Test each workloads with ckpt mode
# ckpt mode will continuously doing checkpoint
for workload in redis pca kmeans memcached
do
mkdir -p $logdir/$workload

View File

@ -3,7 +3,10 @@
source ../config.sh
mkdir -p ./result
# parse logs in $logbasedir/ext-sync/base and ext
# save data in ./result/ext-sync-base.csv and ./result/ext-sync-ext.csv
python read_data.py $logbasedir/ext-sync/base base
python read_data.py $logbasedir/ext-sync/ext ext
# draw fig12 with saved data
python draw_fig12.py ./result/ext-sync-base.csv ./result/ext-sync-ext.csv
echo "fig12 is saved in ./result"

View File

@ -8,11 +8,13 @@ mkdir -p $logdir
loop=(0)
intervals=(0 1 5 10)
# Test redis set benchmark with different checkpoint interval
for freq in ${intervals[@]}
do
mkdir -p $logdir/$freq
for run in ${loop[@]}
do
# checkpoint interval == 0 means raw mode without checkpointing
if [ $freq == 0 ]; then
$appdir/redis.exp raw set 32 2>&1 | tee $logdir/ckpt0.pip32.$run.log
else

View File

@ -8,6 +8,7 @@ mkdir -p $logdir
loop=(0)
intervals=(1 5 10)
# Test redis set benchmark with different checkpoint interval
for freq in ${intervals[@]}
do
for run in ${loop[@]}

View File

@ -3,6 +3,8 @@
source ../config.sh
mkdir -p ./result
# parse logs and save data in "./result/memcached-GET/SET.csv"
python read_memcached.py $logbasedir/memcached
# draw fig11 with saved data
python draw_fig11.py './result/'
echo "fig11 is saved in ./result"

View File

@ -8,11 +8,13 @@ mkdir -p $logdir
loop=(0)
intervals=(0 1 5 10 50)
# Test memcached benchmark with different checkpoint interval
for freq in ${intervals[@]}
do
for run in ${loop[@]}
do
f=t8.$run.log
# checkpoint interval == 0 means raw mode without checkpointing
if [ $freq == 0 ]; then
$appdir/memcached.exp raw 2>&1 | tee $logdir/ckpt0.$f
else

View File

@ -3,6 +3,8 @@
source ../config.sh
mkdir -p "./result"
# parse logs and save data in "./result/ycsb.csv"
python read_ycsb.py $logbasedir/ycsb
# draw fig13 with saved data
python draw_ycsb.py "./result/ycsb.csv" "./result/fig13.jpg"
echo "fig13 is saved in ./result"

View File

@ -6,19 +6,21 @@ logdir=$logbasedir/ycsb
loop=(0)
threads=(1)
mkdir -p $logdir
mkdir -p $logdir/chcore-baseline
mkdir -p $logdir/chcore-ckpt1ms
for workload in a b c g
# Test ycsb benchmark with different workload
# workload configs are given in user/demos/YCSB-C/workloads/
for workload in a b c h
do
for thread in ${threads[@]}
do
for run in ${loop[@]}
do
# baseline
$appdir/ycsb.exp raw $workload $thread 2>&1 | tee $logdir/chcore-baseline/$workload.chcore-raw.t$thread.$run.log
sleep 10
# with checkpoint
$appdir/ycsb.exp ckpt $workload $thread 2>&1 | tee $logdir/chcore-ckpt1ms/$workload.chcore-1msckpt.t$thread.$run.log
sleep 10
done

View File

@ -3,6 +3,8 @@
source ../config.sh
mkdir -p ./result
python read_rocksdb.py $logbasedir/rocksdb
# parse logs and save data in "./result/rocksdb.csv"
python read_rocksdb.py $logbasedir/rocksdb/1/
# draw fig14 with saved data
python draw_rocksdb.py "./result/rocksdb.csv"
echo "fig14(a,b,c,d) are saved in ./result"

View File

@ -7,6 +7,7 @@ threads=(1)
mkdir -p $logdir
# Test rocksdb benchmark with and without taking checkpoint
for thread in ${threads[@]}
do
for run in ${loop[@]}
@ -16,11 +17,6 @@ do
$appdir/rocksdb.exp raw $thread 2>&1 | tee $logdir/$thread/chcore-base/$run.out
sleep 10
# baseline with WAL
# mkdir -p $logdir/chcore-base-wal
# $appdir/rocksdb.exp wal 2>&1 | tee $logdir/chcore-base-wal/$run.out
# sleep 10
# with ckpt
mkdir -p $logdir/$thread/chcore-ckpt
$appdir/rocksdb.exp ckpt $thread 1 0 2>&1 | tee $logdir/$thread/chcore-ckpt/$run.out

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,53 +35,44 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 300
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
set timeout 300
# raw mode: just running default application
if {$mode == "raw"} {
puts "do nothing"
}
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
puts "test default system with $freq ms checkpoint"
send -- "checkpoint.bin -i %$freq -l $log -a 14 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 &\r"
expect "Launching /checkpoint.bin"
}
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
puts "test default system with $freq ms checkpoint\n"
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\n"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\n"
expect "Launching /checkpoint.bin"
expect "Checkpoint finished"
}
# restore mode: take a checkpoint and call shutdown to restore
if {$mode == "restore-log" || $mode == "restore-test"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 4 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 4 &\r"
expect "Checkpoint finished"
send -- "shutdown.bin 0 & \r"
expect "restore from ckpt"

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,59 +35,47 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 300
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
set timeout 300
# Test 1
# raw mode: just running default application
if {$mode == "raw"} {
puts "test raw kmeans"
}
# Test 2
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
puts "test kmeans with 1ms checkpoint"
send -- "checkpoint.bin -i %$freq -l 0 -a 14 &\r"
send -- "checkpoint.bin -i %$freq -l 0 -a 9 &\r"
expect "Launching /checkpoint.bin"
sleep 5
}
send -- "kmeans.bin -p 500000 &\r"
# Launch kmeans with $kmeans_num points
send -- "kmeans.bin -p $kmeans_num &\r"
# Test 3
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\r"
expect "Launching /checkpoint.bin"
expect "Checkpoint finished"
}
# Test 4
# restore mode: take a checkpoint and call shutdown to restore
if {$mode == "restore-log" || $mode == "restore-test"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 4 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 4 &\r"
expect "Checkpoint finished"
send -- "shutdown.bin 0 & \r"
expect "restore from ckpt"

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,19 +35,6 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 300
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
@ -50,55 +45,53 @@ send -- "idle.bin &\r"
expect "Launching /idle.bin"
sleep 1
# Test 1
# raw mode: just running default application
if {$mode == "raw"} {
puts "test raw leveldb"
send -- "leveldb-dbbench --benchmarks=fillbatch --num=1000000 &\r"
send -- "leveldb-dbbench --benchmarks=fillbatch --num=$leveldb_num &\r"
expect "Launching /leveldb-dbbench"
}
# Test 2
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
puts "test leveldb with $freq ms checkpoint"
send -- "leveldb-dbbench --benchmarks=fillbatch --num=1000000 &\r"
send -- "leveldb-dbbench --benchmarks=fillbatch --num=$leveldb_num &\r"
expect "Launching /leveldb-dbbench"
send -- "checkpoint.bin -i %$freq -l $log -a 14 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 &\r"
expect "Launching /checkpoint.bin"
sleep 5
}
# Test 3
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "leveldb-dbbench --benchmarks=fillbatch --num=1000000 &\r"
send -- "leveldb-dbbench --benchmarks=fillbatch --num=$leveldb_num &\r"
expect "Launching /leveldb-dbbench"
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\r"
expect "Launching /checkpoint.bin"
expect "Checkpoint finished"
expect "Microseconds per op"
}
# Test 4
# restore mode: take a checkpoint and call shutdown to restore
if {$mode == "restore-log" || $mode == "restore-test"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "leveldb-dbbench --benchmarks=fillbatch --num=5000000 &\r"
send -- "leveldb-dbbench --benchmarks=fillbatch --num=$leveldb_num &\r"
expect "Launching /leveldb-dbbench"
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 4 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 4 &\r"
expect "Checkpoint finished"
send -- "shutdown.bin 0 & \r"
expect "restore from ckpt"
}
if {$mode != "ckpt-log" && $mode != "restore-log"} {
expect "file:/chos/kernel/object/recycle.c"
expect "Microseconds per op"
}

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,20 +35,6 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 300
while {1} {
send -- "\n"
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
@ -48,43 +42,45 @@ if {$test_mode == "QEMU"} {
set timeout 1200
set thread 8
# Launch memcached server ($thread threaded)
send -- "memcached -l 127.0.0.1 -p 123 -t $thread & \r"
expect "poll fd server is not lwip"
# Test 1
# raw mode: just running default application
if {$mode == "raw"} {
puts "do nothing"
}
# Test 2
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 &\n"
send -- "checkpoint.bin -i %$freq -l $log -a 9 &\n"
expect "Launching /checkpoint.bin"
sleep 5
}
send -- "memcachetest -h 127.0.0.1:123 -M 1024 -F -t $thread -i 100000 &\r"
# Launch memcached client ($thread threaded)
send -- "memcachetest -h 127.0.0.1:123 -M 1024 -F -t $thread -i $memcached_num &\r"
expect "Launching /memcachetest"
# Test 3
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\r"
expect "Launching /checkpoint.bin"
expect "Checkpoint finished"
}
# Test 4
# restore mode: take a checkpoint and call shutdown to restore
if {$mode == "restore-log" || $mode == "restore-test"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 4 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 4 &\r"
expect "Checkpoint finished"
send -- "shutdown.bin 0 & \r"

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,45 +35,37 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 300
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
set timeout 300
# PCA
# Test 1
# Test 2
# raw mode: just running default application
if {$mode == "raw"} {
puts "do nothing"
}
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
puts "test pca with $freq ms checkpoint"
send -- "checkpoint.bin -i %$freq -l $log -a 14 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 &\r"
expect "Launching /checkpoint.bin"
sleep 5
}
send -- "pca.bin -r 1000 -c 1000 &\r"
# Launch pca with $pca_num rows and $pca_num colums
send -- "pca.bin -r $pca_num -c $pca_num &\r"
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\r"
expect "Launching /checkpoint.bin"
}

View File

@ -1,9 +1,8 @@
#!/usr/bin/expect -f
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
set workload [lindex $argv 1]
set pipeline [lindex $argv 2]
@ -18,10 +17,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -30,19 +37,6 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 60
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
@ -58,17 +52,17 @@ if {$mode == "raw"} {
send -- "redis-server --save \"\" -h 127.0.0.1 &\r"
expect "poll fd server is not lwip"
# Test 2
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 3]
set log [lindex $argv 4]
send -- "checkpoint.bin -i %$freq -l $log -a 14 &\n"
send -- "checkpoint.bin -i %$freq -l $log -a 9 &\n"
expect "Launching /checkpoint.bin"
sleep 5
}
# Launch redis clients
set thread 8
if {$pipeline == "nopipe"} {
# no pipeline mode
send -- "redis-benchmark -t $workload -n 3000000 -d 1024 --threads $thread &\r"
@ -78,22 +72,22 @@ if {$pipeline == "nopipe"} {
}
expect "Launching /redis-benchmark"
# Test 3
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 3]
set log [lindex $argv 4]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\r"
expect "Launching /checkpoint.bin"
expect "Checkpoint finished"
}
# Test 4
# restore mode: take a checkpoint and call shutdown to restore
if {$mode == "restore-log" || $mode == "restore-test"} {
set freq [lindex $argv 3]
set log [lindex $argv 4]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 4 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 4 &\r"
expect "Checkpoint finished"
send -- "shutdown.bin 0 & \r"
expect "restore from ckpt"

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,43 +35,29 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 60
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
set timeout 1200
# Test 1
# raw mode: just running default application
if {$mode == "raw"} {
puts "test raw prefix_dist"
}
# Test 2
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 2]
set log [lindex $argv 3]
puts "test prefix_dist with $freq ms checkpoint"
send -- "checkpoint.bin -i %$freq -l $log -a 14 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 &\r"
expect "Launching /checkpoint.bin"
sleep 5
}
set ROCKSDB_NUM 1000000
set ROCKSDB_DUR 30
# Launch rocksdb with benchmarks=fillbatch,mixgraph
set thread [lindex $argv 1]
set timeout 60
@ -80,12 +74,11 @@ while 1 {
--threads=$thread &\r"
expect "Launching /rocksdb-dbbench"
expect {
"DB path:" { break }
"Microseconds per seek" { break }
timeout { continue }
}
}
set timeout 1200
expect "mixgraph"
expect "Microseconds per read:"
expect "Microseconds per read"
expect "100.000%"

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,59 +35,47 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 60
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
set timeout 300
# Test 1
# raw mode: just running default application
if {$mode == "raw"} {
puts "test raw sqlite3"
}
# Test 2
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
puts "test sqlite3 with 1ms checkpoint"
send -- "checkpoint.bin -i %$freq -l $log -a 14 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 &\r"
expect "Launching /checkpoint.bin"
sleep 5
}
# Launch sqlite
send -- "test-sqlite3.bin tmpfs &\r"
# Test 3
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\r"
expect "Launching /checkpoint.bin"
expect "Checkpoint finished"
}
# Test 4
# restore mode: take a checkpoint and call shutdown to restore
if {$mode == "restore-log" || $mode == "restore-test"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 4 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 4 &\r"
expect "Checkpoint finished"
send -- "shutdown.bin 0 & \r"
expect "restore from ckpt"

View File

@ -1,42 +0,0 @@
#!/usr/bin/expect -f
proc start_qemu {} {
source ../config.exp
spawn -noecho rm [exec sh -c {echo "/tmp/nvm-file-$USER"}]
spawn $basedir/build/simulate.sh
expect "Welcome to ChCore shell!"
}
proc start_ipmi {} {
source ../config.exp
while {1} {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
expect {
"SOL Session operational" {
puts "ipmi connected"
break
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
continue
}
timeout {
puts "ipmitool failed"
exit
}
}
}
set timeout 60
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
}

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,59 +35,47 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 60
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
set timeout 1200
# Test 1
# raw mode: just running default application
if {$mode == "raw"} {
puts "test raw word count"
}
# Test 2
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
puts "test word count with 1ms checkpoint"
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 2000 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 2000 &\r"
expect "Launching /checkpoint.bin"
sleep 5
}
# Launch word_count
send -- "word_count.bin word_100MB.txt &\r"
# Test 3
# ckpt-log mode: taking $ckptlogtimes times of checkpoint with log
if {$mode == "ckpt-log"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t $ckptlogtimes &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t $ckptlogtimes &\r"
expect "Launching /checkpoint.bin"
expect "Checkpoint finished"
}
# Test 4
# restore mode: take a checkpoint and call shutdown to restore
if {$mode == "restore-log" || $mode == "restore-test"} {
set freq [lindex $argv 1]
set log [lindex $argv 2]
send -- "checkpoint.bin -i %$freq -l $log -a 14 -t 4 &\r"
send -- "checkpoint.bin -i %$freq -l $log -a 9 -t 4 &\r"
expect "Checkpoint finished"
send -- "shutdown.bin 0 & \r"
expect "restore from ckpt"

View File

@ -2,7 +2,7 @@
source ../config.exp
set timeout 20
set timeout 120
set mode [lindex $argv 0]
if {$test_mode == "QEMU"} {
@ -15,10 +15,18 @@ if {$test_mode == "QEMU"} {
expect {
"SOL Session operational" {
puts "ipmi connected"
break
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
}
}
"SOL payload already active on another session" {
spawn spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol activate
spawn ipmitool -H $ipmi_ip -U $username -P $passwd -I lanplus sol deactivate
continue
}
timeout {
@ -27,19 +35,6 @@ if {$test_mode == "QEMU"} {
}
}
}
set timeout 60
while {1} {
send -- "shutdown.bin \r"
expect {
"Welcome to ChCore shell!" { break }
"No such binary" { continue }
timeout {
puts "shutdown fail"
continue
}
}
}
} else {
puts "Currently, we only support IPMI and QEMU mode!"
}
@ -56,9 +51,9 @@ expect "poll fd server is not lwip"
send -- "set_poll_loop_time.bin -n $threads &\r"
expect "Launching /set_poll_loop_time.bin"
# Lauch checkpoint thread if needed
# ckpt mode: taking checkpoint while running
if {$mode == "ckpt"} {
send -- "checkpoint.bin -i %1 -l 0 -a 7 &\r"
send -- "checkpoint.bin -i %1 -l 0 -a 9 &\r"
expect "Launching /checkpoint.bin"
}
@ -66,7 +61,6 @@ sleep 5
# Start the YCSB benchmark
set timeout 1200
send -- "ycsbc -db redis -threads $threads -P workload$workload.spec -host 127.0.0.1 -port 6379 -slaves 0 &\r"
expect "Launching"

View File

@ -15,7 +15,14 @@ set white_color "\033\[37m"
set red_color "\033\[31m"
# loop time for ckpt log
set ckptlogtimes 1000
set ckptlogtimes 500
set leveldb_num 10000
set redis_num 10000
set memcached_num 10000
set kmeans_num 5000
set pca_num 1000
set ROCKSDB_NUM 1000
set ROCKSDB_DUR 10
# ipmi ip, username and passwd
set ipmi_ip "192.168.12.60"

View File

@ -1,2 +0,0 @@
#!/bin/bash
echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

View File

@ -1,8 +0,0 @@
#!/bin/bash
pmem_dir=/mnt/treesls
pmem_dev=/dev/pmem0
echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
sudo rm -rf $pmem_dir/*
sudo umount $pmem_dir
sudo mkfs.ext4 -F -b 4096 $pmem_dev
sudo mount -o dax $pmme_dev $pmem_dir

View File

@ -1,6 +0,0 @@
#!/bin/bash
disk_dir=/mnt/treesls
disk_dev=/dev/nvme0n1p1
echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
sudo umount $disk_dir
sudo mount $disk_dev $disk_dir

View File

@ -1,37 +0,0 @@
#!/bin/bash
loop=(0)
threads=(1)
restart()
{
mode=$1
kill -9 $(pidof redis-server)
sleep 5
if [ $mode = "nvm-log" ]; then
./dax_config.sh
elif [ $mode = "disk-log" ]; then
./disk_config.sh
else
./config.sh
fi
sleep 5
}
for mode in "baseline" "nvm-log" "disk-log"
#for mode in "nvm-log" "disk-log"
do
for workload in a b c g
do
for thread in ${threads[@]}
do
for run in ${loop[@]}
do
restart $mode
./run_redis_server.sh $mode > /dev/null
sleep 5
./run_ycsb.sh $workload $thread $run $mode
sleep 5
done
done
done
done