souffle::RecordMap Class Reference

Bidirectional mappping between records and record references. More...

#include <RecordTable.h>

Collaboration diagram for souffle::RecordMap:

Data Structures
struct	RecordHash
	hash function for unordered record map More...

Public Member Functions
RamDomain	pack (const RamDomain *tuple)
	convert record pointer to a record reference More...
RamDomain	pack (std::vector< RamDomain > vector)
	converts record to a record reference More...
	RecordMap (size_t arity)
const RamDomain *	unpack (RamDomain index) const
	convert record reference to a record pointer More...

Private Attributes
const size_t	arity
	arity of record More...
std::vector< std::vector< RamDomain > >	indexToRecord
	array of records; index represents record reference More...
std::unordered_map< std::vector< RamDomain >, RamDomain, RecordHash >	recordToIndex
	map from records to references More...

Detailed Description

Bidirectional mappping between records and record references.

Definition at line 40 of file RecordTable.h.

Constructor & Destructor Documentation

RecordMap()

souffle::RecordMap::RecordMap ( size_t  arity )

inlineexplicit

Definition at line 72 of file RecordTable.h.

Member Function Documentation

pack() [1/2]

RamDomain souffle::RecordMap::pack ( const RamDomain *  tuple )

inline

convert record pointer to a record reference

Definition at line 97 of file RecordTable.h.

                                                   {
        const RamDomain* res;
#pragma omp critical(record_unpack)
        res = indexToRecord[index].data();
        return res;
    }
};
 
class RecordTable {
public:
    RecordTable() = default;
    virtual ~RecordTable() = default;

References indexToRecord.

pack() [2/2]

RamDomain souffle::RecordMap::pack ( std::vector< RamDomain >  vector )

inline

converts record to a record reference

Definition at line 76 of file RecordTable.h.

                                           {
        // TODO (b-scholz): data is unnecessarily copied
        // for a successful lookup. To avoid this, we should
        // compute a hash of the pointer-array and traverse through
        // the bucket list of the unordered map finding the record.
        // Note that in case of non-existence, the record still needs to be
        // copied for the newly created entry but this will be the less
        // frequent case.
        std::vector<RamDomain> tmp(arity);
        for (size_t i = 0; i < arity; i++) {
            tmp[i] = tuple[i];
        }

unpack()

const RamDomain* souffle::RecordMap::unpack ( RamDomain  index ) const

inline

convert record reference to a record pointer

Definition at line 113 of file RecordTable.h.

                                                         {
        return lookupArity(arity).pack(tuple);
    }
    /** @brief convert record reference to a record */
    const RamDomain* unpack(RamDomain ref, size_t arity) const {
        std::unordered_map<size_t, RecordMap>::const_iterator iter;

Field Documentation

arity

const size_t souffle::RecordMap::arity

private

arity of record

Definition at line 49 of file RecordTable.h.

indexToRecord

std::vector<std::vector<RamDomain> > souffle::RecordMap::indexToRecord

private

array of records; index represents record reference

Definition at line 69 of file RecordTable.h.

Referenced by pack().

recordToIndex

std::unordered_map<std::vector<RamDomain>, RamDomain, RecordHash> souffle::RecordMap::recordToIndex

private

map from records to references

Definition at line 65 of file RecordTable.h.

---

The documentation for this class was generated from the following file:

• include/souffle/RecordTable.h