/*
* Calculate hash value for a key
*/
static uint32
pgss_hash_fn(const void *key, Size keysize)
{
const pgssHashKey *k = (const pgssHashKey *) key;
/* we don't bother to include encoding in the hash */
return hash_uint32((uint32) k->userid) ^
hash_uint32((uint32) k->dbid) ^
DatumGetUInt32(hash_any((const unsigned char *) k->query_ptr,
k->query_len));
}
/*
* oid_hash: hash function for keys that are OIDs
*
* (tag_hash works for this case too, but is slower)
*/
uint32
oid_hash(const void *key, size_t keysize)
{
ASSERT(keysize == sizeof(oid_t));
return D_TO_UINT32(hash_uint32((uint32) *((const oid_t *) key)));
}
void SPPMPassCallback::pre_render(
const Frame& frame,
JobQueue& job_queue,
IAbortSwitch& abort_switch)
{
if (m_initial_lookup_radius > 0.0f)
{
RENDERER_LOG_INFO(
"sppm lookup radius is %f (%s of initial radius).",
m_lookup_radius,
pretty_percent(m_lookup_radius, m_initial_lookup_radius, 3).c_str());
}
m_stopwatch.start();
// Create a new set of photons.
m_photons.clear_keep_memory();
m_photon_tracer.trace_photons(
m_photons,
hash_uint32(m_pass_number),
job_queue,
abort_switch);
// Stop there if rendering was aborted.
if (abort_switch.is_aborted())
return;
// Build a new photon map.
m_photon_map.reset(new SPPMPhotonMap(m_photons));
}
/*
* Construct an empty TupleHashTable
*
* numCols, keyColIdx: identify the tuple fields to use as lookup key
* eqfunctions: equality comparison functions to use
* hashfunctions: datatype-specific hashing functions to use
* nbuckets: initial estimate of hashtable size
* additionalsize: size of data stored in ->additional
* tablecxt: memory context in which to store table and table entries
* tempcxt: short-lived context for evaluation hash and comparison functions
*
* The function arrays may be made with execTuplesHashPrepare(). Note they
* are not cross-type functions, but expect to see the table datatype(s)
* on both sides.
*
* Note that keyColIdx, eqfunctions, and hashfunctions must be allocated in
* storage that will live as long as the hashtable does.
*/
TupleHashTable
BuildTupleHashTable(int numCols, AttrNumber *keyColIdx,
FmgrInfo *eqfunctions,
FmgrInfo *hashfunctions,
long nbuckets, Size additionalsize,
MemoryContext tablecxt, MemoryContext tempcxt,
bool use_variable_hash_iv)
{
TupleHashTable hashtable;
Size entrysize = sizeof(TupleHashEntryData) + additionalsize;
Assert(nbuckets > 0);
/* Limit initial table size request to not more than work_mem */
nbuckets = Min(nbuckets, (long) ((work_mem * 1024L) / entrysize));
hashtable = (TupleHashTable)
MemoryContextAlloc(tablecxt, sizeof(TupleHashTableData));
hashtable->numCols = numCols;
hashtable->keyColIdx = keyColIdx;
hashtable->tab_hash_funcs = hashfunctions;
hashtable->tab_eq_funcs = eqfunctions;
hashtable->tablecxt = tablecxt;
hashtable->tempcxt = tempcxt;
hashtable->entrysize = entrysize;
hashtable->tableslot = NULL; /* will be made on first lookup */
hashtable->inputslot = NULL;
hashtable->in_hash_funcs = NULL;
hashtable->cur_eq_funcs = NULL;
/*
* If parallelism is in use, even if the master backend is performing the
* scan itself, we don't want to create the hashtable exactly the same way
* in all workers. As hashtables are iterated over in keyspace-order,
* doing so in all processes in the same way is likely to lead to
* "unbalanced" hashtables when the table size initially is
* underestimated.
*/
if (use_variable_hash_iv)
hashtable->hash_iv = hash_uint32(ParallelWorkerNumber);
else
hashtable->hash_iv = 0;
hashtable->hashtab = tuplehash_create(tablecxt, nbuckets, hashtable);
return hashtable;
}
/*
* oid_hash: hash function for keys that are OIDs
*
* (tag_hash works for this case too, but is slower)
*/
uint32
oid_hash(const void *key, Size keysize)
{
Assert(keysize == sizeof(Oid));
return DatumGetUInt32(hash_uint32((uint32) *((const Oid *) key)));
}
static void
test_hash_uint32() {
uint32_t key = 123;
assert_int_equal( 123, hash_uint32( ( void * ) &key ) );
}
/*
* uint32_hash: hash function for keys that are uint32 or int32
*
* (tag_hash works for this case too, but is slower)
*/
uint32
uint32_hash(const void *key, Size keysize)
{
Assert(keysize == sizeof(uint32));
return DatumGetUInt32(hash_uint32(*((const uint32 *) key)));
}
