diff --git a/spec/benchmark-cars.cr b/spec/benchmark-cars.cr index bfbf1e1..bb1f535 100644 --- a/spec/benchmark-cars.cr +++ b/spec/benchmark-cars.cr @@ -6,12 +6,12 @@ require "./db-cars.cr" # ENV["CARNAME"] rescue "Corvet-#{(db_size/2).to_i}" # ENV["CARCOLOR"] rescue "red" # ENV["CARKEYWORD"] rescue "spacious" -# ENV["DBSIZE"] rescue 40_000 -# ENV["DBSIZE_START"] rescue 5_000 +# ENV["DBSIZE"] rescue 50_000 +# ENV["DBSIZE_START"] rescue 1_000 # ENV["DBSIZE_INCREMENT"] rescue 1_000 # ENV["REPORT_DIR"] rescue "results" # ENV["NBRUN"] rescue 100 -# ENV["INDEXESMAXIT"] rescue 5000 +# ENV["MAXINDEXES"] rescue 5_000 class DODB::Storage(V) def empty_db @@ -22,32 +22,58 @@ end class Context class_property report_dir = "results" + class_property max_indexes = 5_000 + class_property nb_run = 100 + class_property from = 1_000 + class_property to = 50_000 + class_property incr = 1_000 end -def report(storage, nb_run, name, &block) - durations = run_n_times nb_run, &block - File.open("#{Context.report_dir}/#{name}", "w") do |file| +def report(storage, name, &block) + durations = run_n_times Context.nb_run, &block + File.open("#{Context.report_dir}/#{name}.raw", "w") do |file| durations.each do |d| file.puts d end end - avr = durations.reduce { |a, b| a + b } / nb_run + avr = durations.reduce { |a, b| a + b } / Context.nb_run puts "#{name}: #{avr}" avr end -def prepare_env(storage, db_size, name, s_index, s_partition, s_tags, &) - STDOUT.write "add #{db_size} values to #{name}\r".to_slice - index_max_iterations = ENV["INDEXESMAXIT"].to_i rescue 5_000 - add_cars storage, db_size, max_it_tags: (db_size > index_max_iterations ? 0 : 5000) +def long_operation(text) + STDOUT.write "#{text}\r".to_slice + yield STDOUT.write " \r".to_slice - - yield storage, name, s_index, s_partition, s_tags - - storage.rm_storage_dir end -def batch(db_size, nb_run) +def verbose_add_cars(storage, nbcars, name, max_indexes) + long_operation "add #{nbcars} values to #{name}" do + add_cars storage, nbcars, max_indexes: max_indexes + end +end + +# Add first entries, then loop: speed tests, add entries. +def prepare_env(storage, name, s_index, s_partition, s_tags, &) + verbose_add_cars storage, Context.from, name, max_indexes: Context.max_indexes + + current = Context.from + to = Context.to + incr = Context.incr + + while current < to + yield storage, current, name, s_index, s_partition, s_tags + + break if current + incr >= to + + verbose_add_cars storage, incr, name, max_indexes: Context.max_indexes + current += incr + end + + long_operation "removing #{name} data" { storage.rm_storage_dir } +end + +def batch() cars_ram = DODB::RAMOnlySpecDataBase(Car).new cars_cached = DODB::CachedSpecDataBase(Car).new cars_semi = DODB::SpecDataBase(Car).new "-semi" @@ -58,42 +84,38 @@ def batch(db_size, nb_run) semi_Sby_name, semi_Sby_color, semi_Sby_keywords = cached_indexes cars_semi uncached_Sby_name, uncached_Sby_color, uncached_Sby_keywords = uncached_indexes cars_uncached - car_name_to_search = ENV["CARNAME"] rescue "Corvet-#{(db_size/2).to_i}" - car_color_to_search = ENV["CARCOLOR"] rescue "red" - car_keyword_to_search = ENV["CARKEYWORD"] rescue "spacious" - - puts "" - puts "NEW BATCH: db-size #{db_size}" - puts "" - puts "search by index '#{car_name_to_search}', partition '#{car_color_to_search}', tag '#{car_keyword_to_search}'" - fn = ->(storage : DODB::Storage(Car), + current_db_size : Int32, name : String, search_name : DODB::Index(Car), search_color : DODB::Partition(Car), search_keywords : DODB::Tags(Car)) { - report(storage, nb_run, "#{name}_#{db_size}_index") do - corvet = search_name.get car_name_to_search + + name_to_search = ENV["CARNAME"] rescue "Corvet-#{(current_db_size/2).to_i}" + color_to_search = ENV["CARCOLOR"] rescue "red" + keyword_to_search = ENV["CARKEYWORD"] rescue "spacious" + puts "NEW BATCH: db-size #{current_db_size}, name: '#{name_to_search}', color: '#{color_to_search}', tag: '#{keyword_to_search}'" + report(storage, "#{name}_#{current_db_size}_index") do + corvet = search_name.get name_to_search end - report(storage, nb_run, "#{name}_#{db_size}_partitions") do - corvet = search_color.get? car_color_to_search + report(storage, "#{name}_#{current_db_size}_partitions") do + corvet = search_color.get? color_to_search end - report(storage, nb_run, "#{name}_#{db_size}_tags") do - corvet = search_keywords.get? car_keyword_to_search + report(storage, "#{name}_#{current_db_size}_tags") do + corvet = search_keywords.get? keyword_to_search end - puts "" } - prepare_env cars_ram, db_size, "ram", ram_Sby_name, ram_Sby_color, ram_Sby_keywords, &fn - prepare_env cars_cached, db_size, "cached", cached_Sby_name, cached_Sby_color, cached_Sby_keywords, &fn - prepare_env cars_semi, db_size, "semi", semi_Sby_name, semi_Sby_color, semi_Sby_keywords, &fn - prepare_env cars_uncached, db_size, "uncached", uncached_Sby_name, uncached_Sby_color, uncached_Sby_keywords, &fn + prepare_env cars_cached, "cached", cached_Sby_name, cached_Sby_color, cached_Sby_keywords, &fn + prepare_env cars_ram, "ram", ram_Sby_name, ram_Sby_color, ram_Sby_keywords, &fn + prepare_env cars_semi, "semi", semi_Sby_name, semi_Sby_color, semi_Sby_keywords, &fn + prepare_env cars_uncached, "uncached", uncached_Sby_name, uncached_Sby_color, uncached_Sby_keywords, &fn end -def perform_add(storage : DODB::Storage(Car), nb_run) +def perform_add(storage : DODB::Storage(Car)) corvet0 = Car.new "Corvet", "red", [ "shiny", "impressive", "fast", "elegant" ] i = 0 - perform_benchmark_average nb_run, do + perform_benchmark_average Context.nb_run, do corvet = corvet0.clone corvet.name = "Corvet-#{i}" storage << corvet @@ -101,7 +123,7 @@ def perform_add(storage : DODB::Storage(Car), nb_run) end end -def batch_add(nb_run) +def batch_add() cars_ram = DODB::RAMOnlySpecDataBase(Car).new cars_cached = DODB::CachedSpecDataBase(Car).new cars_semi = DODB::SpecDataBase(Car).new "-semi" @@ -112,17 +134,17 @@ def batch_add(nb_run) cached_indexes cars_semi uncached_indexes cars_uncached - avr = perform_add(cars_ram, nb_run) - puts "(ram db and indexes) add a value (average on #{nb_run} tries): #{avr}" + avr = perform_add(cars_ram) + puts "(ram db and indexes) add a value (average on #{Context.nb_run} tries): #{avr}" - avr = perform_add(cars_cached, nb_run) - puts "(cached db and indexes) add a value (average on #{nb_run} tries): #{avr}" + avr = perform_add(cars_cached) + puts "(cached db and indexes) add a value (average on #{Context.nb_run} tries): #{avr}" - avr = perform_add(cars_semi, nb_run) - puts "(uncached db but cached indexes) add a value (average on #{nb_run} tries): #{avr}" + avr = perform_add(cars_semi) + puts "(uncached db but cached indexes) add a value (average on #{Context.nb_run} tries): #{avr}" - avr = perform_add(cars_uncached, nb_run) - puts "(uncached db and indexes) add a value (average on #{nb_run} tries): #{avr}" + avr = perform_add(cars_uncached) + puts "(uncached db and indexes) add a value (average on #{Context.nb_run} tries): #{avr}" cars_ram.rm_storage_dir cars_cached.rm_storage_dir @@ -130,32 +152,20 @@ def batch_add(nb_run) cars_uncached.rm_storage_dir end -ENV["REPORT_DIR"]?.try do |report_dir| - Context.report_dir = report_dir -end +ENV["REPORT_DIR"]?.try { |report_dir| Context.report_dir = report_dir } Dir.mkdir_p Context.report_dir -nb_run = ENV["NBRUN"].to_i rescue 100 -db_size_max = ENV["DBSIZE"].to_i rescue 40_000 -current_size = ENV["DBSIZE_START"].to_i rescue 5_000 -size_increment = ENV["DBSIZE_INCREMENT"].to_i rescue 1_000 -index_max_iterations = ENV["INDEXESMAXIT"].to_i rescue 5_000 +ENV["MAXINDEXES"]?.try { |it| Context.max_indexes = it.to_i } +ENV["NBRUN"]?.try { |it| Context.nb_run = it.to_i } +ENV["DBSIZE"]?.try { |it| Context.to = it.to_i } +ENV["DBSIZE_START"]?.try { |it| Context.from = it.to_i } +ENV["DBSIZE_INCREMENT"]?.try { |it| Context.incr = it.to_i } -# ENV["DBSIZE"] rescue 40_000 -# ENV["DBSIZE_START"] rescue 5_000 -# ENV["DBSIZE_INCREMENT"] rescue 1_000 -# ENV["REPORT_DIR"] rescue "results" -# ENV["NBRUN"] rescue 100 -# ENV["INDEXESMAXIT"] rescue 5000 +pp! Context.nb_run +pp! Context.from +pp! Context.to +pp! Context.incr +pp! Context.max_indexes -pp! nb_run -pp! db_size_max -pp! current_size -pp! size_increment -pp! index_max_iterations - -while current_size <= db_size_max - batch current_size, nb_run - current_size += size_increment -end -batch_add nb_run +batch +batch_add diff --git a/spec/db-cars.cr b/spec/db-cars.cr index f360c70..4f81532 100644 --- a/spec/db-cars.cr +++ b/spec/db-cars.cr @@ -51,8 +51,12 @@ def uncached_indexes(storage : DODB::Storage) return n, c, k end -def add_cars(storage : DODB::Storage, nb_iterations : Int32, from = 0, max_it_tags = 5000) - i = from +# `max_indexes` limits the number of indexes (partitions and tags). +# Once the last index (db last_index/5) is above this value, the following +# cars won't be tagged nor partitionned. +def add_cars(storage : DODB::Storage, nb_iterations : Int32, max_indexes = 5000) + last_index = ((storage.last_index + 1) / 5).to_i + i = 0 car1 = Car.new "Corvet", "red", [ "shiny", "impressive", "fast", "elegant" ] car2 = Car.new "Bullet-GT", "blue", [ "shiny", "fast", "expensive" ] car3 = Car.new "Deudeuche", "beige", [ "curvy", "sublime" ] @@ -60,13 +64,15 @@ def add_cars(storage : DODB::Storage, nb_iterations : Int32, from = 0, max_it_ta car5 = Car.new "C-MAX", "gray", [ "spacious", "affordable" ] while i < nb_iterations - car1.name = "Corvet-#{i}" - car2.name = "Bullet-GT-#{i}" - car3.name = "Deudeuche-#{i}" - car4.name = "Ford-5-#{i}" - car5.name = "C-MAX-#{i}" + car1.name = "Corvet-#{last_index}" + car2.name = "Bullet-GT-#{last_index}" + car3.name = "Deudeuche-#{last_index}" + car4.name = "Ford-5-#{last_index}" + car5.name = "C-MAX-#{last_index}" - if i >= max_it_tags + last_index += 1 + + if last_index > max_indexes car1.color = DODB.no_index car2.color = DODB.no_index car3.color = DODB.no_index