asami.durable.block.file.block-file — org.clojars.quoll/asami 2.3.3

A mapped file implementation of the Block abstraction

block-for clj

(block-for {:keys [nr-blocks block-size stride mapped-byte-buffers]
            :as block-file}
           block-id)

Returns the byte buffer that references the given block.

cache-size clj

clear! clj

(clear! {:keys [block-size stride mapped-byte-buffers file raf fc]
         :as block-file})

copy-block clj

(copy-block {:keys [mapped-byte-buffers block-size stride] :as block-file}
            {:keys [byte-offset ro] :as block}
            new-block-id)

Allocates a new block with a copy of the original block.

create-managed-block-file clj

(create-managed-block-file filename block-size nr-blocks)

force-file clj

(force-file {:keys [mapped-byte-buffers] :as block-file})

Ensures all cached data is written to disk. This returns synchronously after all data is written.

get-nr-blocks clj

(get-nr-blocks {:keys [nr-blocks]})

Returns the number of blocks

LN2 clj

log2 clj

(log2 x)

map-file! clj

(map-file! {:keys [nr-mapped-regions stride mapped-byte-buffers] :as block-file}
           regions)

Expands a block-file to one that is mapped to the required number of regions. Returns a new block-file with the required mappings.

next-size-increment clj

(next-size-increment {:keys [nr-blocks block-size stride] :as block-file})

Determine the next number of blocks that the file should move up to. The size increment of the file increases as the size of the file increases

null clj

open-block-file clj

(open-block-file file block-size init-nr-blocks)

Opens a file for storing blocks. Returns a structure with the block file and the RandomAccessFile that the block file uses. The file will need to be closed when block files based on this initial block file are no longer needed. When the init-nr-blocks is not nil, then it holds the recorded number of blocks in the file.

pow2 clj

(pow2 x)

Raise 2 to the power of x, with a floor value of 1.

power-increment clj

Defines how many bits behind the region magnitude to increment the number of regions by. 4 bits behind means that it starts at incrementing by 1, until size 32. Then 2 until 64. Then 4 until 128, and so on.

region-size clj

retries clj

set-nr-blocks! clj

(set-nr-blocks! {:keys [nr-blocks block-size nr-mapped-regions stride]
                 :as block-file}
                new-nr)

Updates the number of blocks mapped in a block file. Returns the new block-file.

unmap clj

(unmap {:keys [mapped-byte-buffers block-size nr-blocks raf] :as block-file})

Throw away mappings. This is dangerous, as it invalidates all instances. Only to be used when closing the file for good.