shared_rhash Module


Uses


Interfaces

public interface initialise_shared_rht

  • private subroutine initialise_shared_rht_impl(ilut_list, space_size, hash_table, ht_size)

    Default initializer for shared read-only hash-tables, that defaults the determinant size to the number of electrons. This sets up a hash table storing the position of iluts in a given list, such that lookup is done with the shared_rht_lookup function that supports iluts

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=n_int), intent(in) :: ilut_list(0:,:)
    integer, intent(in) :: space_size

    size of the index space
    type(shared_rhash_t), intent(out) :: hash_table

    shared read-only hashtable to index the ilut_list
    integer, intent(in), optional :: ht_size

    optional, the size of the hash table. Defaults to space_size

  • private subroutine initialise_shared_rht_expl(ilut_list, space_size, hash_table, det_size, ht_size)

    Explicit initializer for shared read-only hash-tables that allows to set the determinant size

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=n_int), intent(in) :: ilut_list(0:,:)
    integer, intent(in) :: space_size

    size of the index space
    type(shared_rhash_t), intent(out) :: hash_table

    shared read-only hashtable to index the ilut_list
    integer, intent(in) :: det_size

    size of the determinants encoded in ilut_list (for convenience)
    integer, intent(in) :: ht_size

    the size of the hash table, has to be specified herer!

Derived Types

type, public ::  shared_rhash_t

The shared read-only hash table stores a given number of arbitrary input values in one contiguous array and addresses this contiguous array using a hashtable The input values are stored in order of ascending hash value, with conflicts stored adjacently. For each hash value, the position of the first value with that hash value is stored. The lookup then searches for a given value between the first and the last stored value with the same hash value.

Components

Type Visibility Attributes Name Initial
type(shared_array_int64_t), private :: indices
type(shared_array_int64_t), private :: hval_offsets
integer(kind=int64), private :: hval_range
integer, private, allocatable :: mult(:)
logical, private :: t_conflicts_known = .false.

Type-Bound Procedures

procedure, public :: alloc
procedure, public :: dealloc
procedure, public :: count_value
procedure, public :: add_value
procedure, public :: finalize_setup
procedure, public :: setup_offsets
procedure, public :: direct_lookup
procedure, public :: callback_lookup
procedure, public :: known_conflicts
procedure, public :: val_range
procedure, public :: sync

Functions

private function known_conflicts(this) result(t_kc)

During initialisation, we can only start writing values once the offsets are known. This requires knowledge about the number of conflicts per hash value. This function tells us whether the conflicts have already been counted.

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(in) :: this

Return Value logical

private function val_range(this) result(h_range)

Get the range of hash table values of this ht

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(in) :: this

Return Value integer(kind=int64)


Subroutines

private subroutine alloc(this, n_elem, htsize)

Allocate the internal (shared) memory

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(inout) :: this
integer(kind=int64), intent(in) :: n_elem

number of distinct values to store
integer(kind=int64), intent(in) :: htsize

range of the hash function

private subroutine dealloc(this)

Deallocate all arrays associated with this hash table object

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(inout) :: this

private subroutine count_value(this, hval)

Log the occurence of this hash value in the set of values to be stored Does not add it, only updates the offsets

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(inout) :: this
integer(kind=int64), intent(in) :: hval

hash value to be logged

private subroutine setup_offsets(this)

For performance reasons, we cannot directly calculate the offsets, but instead first count the number of conflicts per hash value. Then, we sum these up cumulatively Directly counting the offsets is horrifically slow

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(inout) :: this

private subroutine add_value(this, hval, index, pos)

Add an input value to the stored values, assuming we already know the offsets

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(inout) :: this
integer(kind=int64), intent(in) :: hval

value to be stored
integer(kind=int64), intent(in) :: index

value to be stored index belonging to this value
integer(kind=int64), intent(out) :: pos

on return, the position where this value was stored

private subroutine finalize_setup(this)

Dealloates temporary arrays used for initialisation

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(inout) :: this

private subroutine direct_lookup(this, hval, index, pos, t_found)

Look up a value in this hash table. Returns whether the value is stored and if yes, where

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(in) :: this
integer(kind=int64), intent(in) :: hval

value to be looked up hash value of the index to look up
integer(kind=int64), intent(in) :: index

value to be looked up
integer(kind=int64), intent(out) :: pos

on return, the position of index if found, else 0
logical, intent(out) :: t_found

on return, true if and only if index was found

private subroutine callback_lookup(this, hval, pos, t_found, loc_verify)

Generic lookup routine, using an external routine for verification DOES NOT TO THE SAME AS direct_lookup

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(in) :: this
integer(kind=int64), intent(in) :: hval

hash value of the index to look up
integer(kind=int64), intent(out) :: pos

on return, the matching entry
logical, intent(out) :: t_found

on return, true if and only if index was found
private function loc_verify(i) result(match)
Arguments
Type IntentOptional Attributes Name
integer(kind=int64), intent(in) :: i
Return Value logical

private subroutine sync(this)

Synchronize the shared resource

Arguments

Type IntentOptional Attributes Name
class(shared_rhash_t), intent(inout) :: this

private subroutine initialise_shared_rht_impl(ilut_list, space_size, hash_table, ht_size)

Default initializer for shared read-only hash-tables, that defaults the determinant size to the number of electrons. This sets up a hash table storing the position of iluts in a given list, such that lookup is done with the shared_rht_lookup function that supports iluts

Arguments

Type IntentOptional Attributes Name
integer(kind=n_int), intent(in) :: ilut_list(0:,:)
integer, intent(in) :: space_size

size of the index space
type(shared_rhash_t), intent(out) :: hash_table

shared read-only hashtable to index the ilut_list
integer, intent(in), optional :: ht_size

optional, the size of the hash table. Defaults to space_size

private subroutine initialise_shared_rht_expl(ilut_list, space_size, hash_table, det_size, ht_size)

Explicit initializer for shared read-only hash-tables that allows to set the determinant size

Arguments

Type IntentOptional Attributes Name
integer(kind=n_int), intent(in) :: ilut_list(0:,:)
integer, intent(in) :: space_size

size of the index space
type(shared_rhash_t), intent(out) :: hash_table

shared read-only hashtable to index the ilut_list
integer, intent(in) :: det_size

size of the determinants encoded in ilut_list (for convenience)
integer, intent(in) :: ht_size

the size of the hash table, has to be specified herer!

public subroutine shared_rht_lookup(core_ht, ilut, nI, tgt_space, i, core_state)

Lookup a value in a shared-read-only hashtable. Returns the position of a given ilut in the target space used for setting up this hash table no need to decode again the given ilut

Arguments

Type IntentOptional Attributes Name
type(shared_rhash_t), intent(in) :: core_ht

hashtable used for the lookup
integer(kind=n_int), intent(in) :: ilut(0:NIfTot)
integer, intent(in) :: nI(:)
integer(kind=int64), intent(in) :: tgt_space(0:,1:)
integer, intent(out) :: i

on return, position of ilut in tgt_space if found, 0 else
logical, intent(out) :: core_state

on return, true if ilut is found, false else