this repo has no description
Make growth factor configurable
+23
-9
+1
-1
lib/xks/manifest.ex
+1
-1
lib/xks/manifest.ex
+1
lib/xks/superblock.ex
+1
lib/xks/superblock.ex
+20
-8
lib/xks/xks.ex
+20
-8
lib/xks/xks.ex
···
75
75
lsm_table_data_blocks_max: pos_integer,
76
76
lsm_subtable_size: pos_integer,
77
77
lsm_memtable_size_limit: pos_integer,
78
+
lsm_growth_factor: pos_integer,
78
79
}
79
80
@enforce_keys [
80
81
:block_size,
···
82
83
:lsm_table_data_blocks_max,
83
84
:lsm_subtable_size,
84
85
:lsm_memtable_size_limit,
86
+
:lsm_growth_factor,
85
87
]
86
88
defstruct @enforce_keys
87
89
end
···
114
116
assert lsm_subtable_size <= block_size
115
117
116
118
lsm_memtable_size_limit = Keyword.get(opts, :lsm_memtable_size_limit, 32 * b_KiB())
119
+
lsm_growth_factor = Keyword.get(opts, :lsm_growth_factor, 2)
117
120
118
121
%Opts{
119
122
block_size: block_size,
···
121
124
lsm_table_data_blocks_max: lsm_table_data_blocks_max,
122
125
lsm_subtable_size: lsm_subtable_size,
123
126
lsm_memtable_size_limit: lsm_memtable_size_limit,
127
+
lsm_growth_factor: lsm_growth_factor,
124
128
}
125
129
end
126
130
···
757
761
free_list: free_list,
758
762
manifest: manifest,
759
763
manifest_log: manifest_log,
760
-
work_queue: work_queue,
761
764
epoch_atomic: epoch_atomic,
762
765
} = xks
763
766
···
809
812
810
813
# subtracting here is kind-of ugly but should always be correct
811
814
input_level = output_level - 1
812
-
maybe_enqueue_compact_level(manifest, work_queue, partition, input_level)
813
-
maybe_enqueue_compact_level(manifest, work_queue, partition, output_level)
815
+
maybe_enqueue_compact_level(xks, partition, input_level)
816
+
maybe_enqueue_compact_level(xks, partition, output_level)
814
817
815
818
# Update epoch *after* all writes are complete so that readers cannot observe torn writes
816
819
:atomics.put(xks.epoch_atomic, 1, new_epoch)
···
818
821
:ok
819
822
end
820
823
821
-
defp maybe_enqueue_compact_level(manifest, work_queue, partition, level) do
824
+
defp maybe_enqueue_compact_level(_xks, _partition, 0 = _level), do: :noop
825
+
defp maybe_enqueue_compact_level(%XKS{} = xks, partition, level) do
826
+
%{
827
+
manifest: manifest,
828
+
work_queue: work_queue,
829
+
opts: %{
830
+
lsm_growth_factor: opt_lsm_growth_factor,
831
+
},
832
+
} = xks
833
+
assert level > 0
822
834
level_table_count = Manifest.get_table_count_for_level(manifest, partition, level)
823
-
target_table_count = level_target(level)
835
+
target_table_count = level_target(opt_lsm_growth_factor, level)
836
+
824
837
case level_table_count > target_table_count do
825
838
true -> WorkQueue.enqueue_compact_level(work_queue, partition, level)
826
839
false -> :noop
827
840
end
828
841
end
829
842
830
-
@level_tables_target {0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}
831
-
defp level_target(level), do: elem(@level_tables_target, level)
843
+
defp level_target(opt_growth_factor, level) when level > 0, do: opt_growth_factor ** level
832
844
833
845
def info_manifest(%XKS{} = xks, partition) when is_integer(partition) do
834
846
%{
···
840
852
max_level = Manifest.get_max_level(manifest, partition)
841
853
842
854
memtables = Manifest.list_memtables(manifest, partition, epoch)
843
-
level_tables = Enum.map(0..max_level, fn level ->
855
+
level_tables = Enum.map(1..max_level, fn level ->
844
856
{
845
857
level,
846
858
Manifest.list_overlapping_tables(manifest, epoch, partition, level, "", "\xFF\xFF\xFF\xFF"),