robin_hood.h

Go to the documentation of this file.

/* This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/* Code: */

#ifndef OPIC_HASH_HASH_TABLE_H
#define OPIC_HASH_HASH_TABLE_H 1

#include <stdbool.h>
#include "opic/common/op_macros.h"
#include "op_hash.h"
#include "opic/op_malloc.h"

OP_BEGIN_DECLS

typedef struct OPHashTable OPHashTable;

typedef struct HTFunnel HTFunnel;

bool HTNew(OPHeap* heap, OPHashTable** table_ref, uint64_t num_objects,
           double load, size_t keysize, size_t valsize);

void HTDestroy(OPHashTable* table);

bool HTInsertCustom(OPHashTable* table, OPHash hasher, void* key, void* val);

bool HTUpsertCustom(OPHashTable* table, OPHash hasher,
                    void* key, void** val_ref, bool* is_duplicate);

void* HTGetCustom(OPHashTable* table, OPHash hasher, void* key);

void* HTDeleteCustom(OPHashTable* table, OPHash hasher, void* key);

static inline bool
HTInsert(OPHashTable* table, void* key, void* val)
{
  return HTInsertCustom(table, OPDefaultHash, key, val);
}

static inline bool
HTUpsert(OPHashTable* table, void* key, void** val_ref, bool* is_duplicate)
{
  return HTUpsertCustom(table, OPDefaultHash, key, val_ref, is_duplicate);
}

static inline void*
HTGet(OPHashTable* table, void* key)
{
  return HTGetCustom(table, OPDefaultHash, key);
}

static inline void*
HTDelete(OPHashTable* table, void* key)
{
  return HTDeleteCustom(table, OPDefaultHash, key);
}

uint64_t HTObjcnt(OPHashTable* table);

uint64_t HTCapacity(OPHashTable* table);

size_t HTKeysize(OPHashTable* table);

size_t HTValsize(OPHashTable* table);

void HTIterate(OPHashTable* table, OPHashIterator iterator, void* context);

void HTPrintStat(OPHashTable* table);

uint32_t HTMaxProbe(OPHashTable* table);

uint32_t HTProbeStat(OPHashTable* table, uint32_t idx);

int HTGetProbeCustom(OPHashTable* table, OPHash hasher, void* key);

static inline
int HTGetProbe(OPHashTable* table, void* key)
{
  return HTGetProbeCustom(table, OPDefaultHash, key);
}

HTFunnel* HTFunnelNewCustom(OPHashTable* table,
                            OPHash hasher,
                            FunnelCB callback,
                            size_t slotsize,
                            size_t partition_size);

static inline
HTFunnel* HTFunnelNew(OPHashTable* table,
                      FunnelCB callback,
                      size_t slotsize,
                      size_t partition_size)
{
  return HTFunnelNewCustom(table, OPDefaultHash, callback,
                           slotsize, partition_size);
}

void HTFunnelDestroy(HTFunnel* funnel);

void HTFunnelPreHashInsert(HTFunnel* funnel,
                           uint64_t hashed_key,
                           void* key, void* value);

void HTFunnelInsert(HTFunnel* funnel, void* key, void* value);

void HTFunnelInsertFlush(HTFunnel* funnel);

void HTFunnelPreHashUpsert(HTFunnel* funnel,
                           uint64_t hashed_key,
                           void* key, void* value,
                           void* context, size_t ctxsize);

void HTFunnelUpsert(HTFunnel* funnel,
                    void* key, void* value,
                    void* context, size_t ctxsize);

void HTFunnelUpsertFlush(HTFunnel* funnel);

void HTFunnelPreHashGet(HTFunnel* funnel, uint64_t hashed_key,
                        void* key, void* context, size_t ctxsize);

void HTFunnelGet(HTFunnel* funnel, void* key, void* context, size_t ctxsize);

void HTFunnelGetFlush(HTFunnel* funnel);

void HTFunnelPreHashDelete(HTFunnel* funnel, uint64_t hashed_key,
                           void* key, void* context, size_t ctxsize);

void HTFunnelDelete(HTFunnel* funnel, void* key,
                    void* context, size_t ctxsize);

void HTFunnelDeleteFlush(HTFunnel* funnel);

OP_END_DECLS

#endif

/* hash_table.h ends here */