this repo has no description
Add SimFile support to BTree.Store
+65
-16
+1
-1
lib/btree/btree.ex
+1
-1
lib/btree/btree.ex
+41
-15
lib/btree/store.ex
+41
-15
lib/btree/store.ex
···
1
1
defmodule Hobbes.BTree.Store do
2
2
alias Hobbes.BTree.BlockDevice
3
3
4
+
alias Trinity.{Sim, SimFile}
5
+
4
6
import ExUnit.Assertions, only: [assert: 1]
5
7
import Hobbes.BTree.Utils
6
8
7
9
@type t :: BlockDevice.t
8
10
@type checksum :: <<_::128>>
9
11
10
-
@spec new(String.t | :memory, pos_integer) :: t
11
-
def new(path, block_size) do
12
-
case path do
13
-
:memory -> BlockDevice.new(block_size)
12
+
@spec new(keyword) :: t
13
+
def new(opts) do
14
+
page_size = Keyword.fetch!(opts, :page_size)
15
+
assert is_integer(page_size)
16
+
assert page_size >= 1
17
+
18
+
case Keyword.fetch!(opts, :path) do
19
+
:memory ->
20
+
BlockDevice.new(page_size)
21
+
22
+
path when is_binary(path) ->
23
+
if not Sim.simulated?() do
24
+
require Logger
25
+
Logger.warning("Opening BTree store at path: #{path}")
26
+
end
27
+
# TODO: :raw
28
+
{:ok, fd} = SimFile.open(path, [:read, :write])
29
+
{:file, page_size, fd}
14
30
end
15
31
end
16
32
···
21
37
end
22
38
23
39
@spec read_superblock(t, non_neg_integer) :: binary
24
-
def read_superblock({:block_device, _, _} = bd, copy) do
40
+
def read_superblock(store, copy) do
25
41
pos = copy * c_superblock_size()
26
-
27
-
BlockDevice.read(bd, pos, c_superblock_size())
42
+
read(store, pos, c_superblock_size())
28
43
end
29
44
30
45
@spec write_superblock(t, non_neg_integer, binary) :: :ok
31
-
def write_superblock({:block_device, _, _} = bd, copy, superblock_data) do
46
+
def write_superblock(store, copy, superblock_data) do
32
47
assert byte_size(superblock_data) == c_superblock_size()
33
48
34
-
:ok = BlockDevice.write(bd, copy * c_superblock_size(), superblock_data)
49
+
pos = copy * c_superblock_size()
50
+
:ok = write(store, pos, superblock_data)
35
51
end
36
52
37
53
@spec read_page(t, non_neg_integer, checksum) :: binary
38
-
def read_page({:block_device, opt_block_size, _} = bd, page_index, checksum) do
39
-
pos = page_index * opt_block_size
40
-
page_data = BlockDevice.read(bd, pos, opt_block_size)
54
+
def read_page({_type, opt_page_size, _ref} = store, page_index, checksum) do
55
+
pos = page_index * opt_page_size
56
+
page_data = read(store, pos, opt_page_size)
41
57
42
58
assert checksum(page_data) == checksum
43
59
page_data
44
60
end
45
61
46
62
@spec write_page(t, non_neg_integer, binary) :: :ok
47
-
def write_page({:block_device, opt_block_size, _} = bd, page_index, page_data) do
48
-
assert byte_size(page_data) == opt_block_size
63
+
def write_page({_type, opt_page_size, _ref} = store, page_index, page_data) do
64
+
assert byte_size(page_data) == opt_page_size
49
65
50
-
:ok = BlockDevice.write(bd, page_index * opt_block_size, page_data)
66
+
pos = page_index * opt_page_size
67
+
:ok = write(store, pos, page_data)
51
68
end
69
+
70
+
defp read({:block_device, _, _} = bd, pos, bytes), do: BlockDevice.read(bd, pos, bytes)
71
+
defp read({:file, _, fd}, pos, bytes) do
72
+
{:ok, data} = SimFile.pread(fd, pos, bytes)
73
+
data
74
+
end
75
+
76
+
defp write({:block_device, _, _} = bd, pos, data), do: BlockDevice.write(bd, pos, data)
77
+
defp write({:file, _, fd}, pos, data), do: SimFile.pwrite(fd, pos, data)
52
78
end
+23
test/btree_test.exs
+23
test/btree_test.exs
···
16
16
iterations: 1000,
17
17
#key_bits: 8,
18
18
key_bits: 32,
19
+
btree_opts: [
20
+
],
19
21
])
22
+
end
23
+
end
24
+
25
+
defmodule ModelFileFuzzTest do
26
+
use ExUnit.Case, async: true
27
+
@moduletag :btree
28
+
@moduletag :btree_fuzz
29
+
@moduletag :btree_file
30
+
@moduletag :btree_model_file
31
+
32
+
test "fuzz" do
33
+
Trinity.Sim.run_simulation(fn ->
34
+
Hobbes.BTree.Fuzz.ModelFuzz.run(100, [
35
+
iterations: 1000,
36
+
#key_bits: 8,
37
+
key_bits: 32,
38
+
btree_opts: [
39
+
path: "/fuzz.btree",
40
+
],
41
+
])
42
+
end)
20
43
end
21
44
end
22
45