this repo has no description
2
fork

Configure Feed

Select the types of activity you want to include in your feed.

Add SimFile support to BTree.Store

garrison 82acdeb8 8014fde7

+65 -16
+1 -1
lib/btree/btree.ex
··· 57 57 58 58 btree = %BTree{ 59 59 opts: opts, 60 - store: Store.new(path, opts.page_size), 60 + store: Store.new(path: path, page_size: opts.page_size), 61 61 free_list: FreeList.new(page_size: opts.page_size), 62 62 root_store: :ets.new(__MODULE__, [:ordered_set, :protected]), 63 63
+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
··· 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