inline void dense_set::merge (size_t i, size_t j __attribute__((unused)))
{
POMAGMA_ASSERT5(0 < i and i <= m_item_dim, "rep out of range: " << i);
POMAGMA_ASSERT5(0 < j and j <= m_item_dim, "dep out of range: " << j);
POMAGMA_ASSERT5(i != j, "merge with self: " << i);
POMAGMA_ASSERT5(i > j, "merge wrong order: " << i << " > " << j);
POMAGMA_ASSERT4(contains(i), "merge rep not contained: " << i);
POMAGMA_ASSERT4(contains(j), "merge dep not contained: " << j);
_bit(i).zero();
}
inline void dense_bin_fun::remove (oid_t lhs, oid_t rhs)
{
oid_t & old_val = value(lhs, rhs);
POMAGMA_ASSERT2(old_val, "double removal: " << lhs << "," << rhs);
old_val = 0;
bool_ref Lx_bit = m_lines.Lx(lhs, rhs);
POMAGMA_ASSERT4(Lx_bit, "double removal: " << lhs << "," << rhs);
Lx_bit.zero();
bool_ref Rx_bit = m_lines.Rx(lhs, rhs);
POMAGMA_ASSERT4(Rx_bit, "double removal: " << lhs << "," << rhs);
Rx_bit.zero();
}
inline void dense_bin_fun::insert (oid_t lhs, oid_t rhs, oid_t val)
{
oid_t & old_val = value(lhs, rhs);
POMAGMA_ASSERT2(not old_val, "double insertion: " << lhs << "," << rhs);
old_val = val;
bool_ref Lx_bit = m_lines.Lx(lhs, rhs);
POMAGMA_ASSERT4(not Lx_bit, "double insertion: " << lhs << "," << rhs);
Lx_bit.one();
bool_ref Rx_bit = m_lines.Rx(lhs, rhs);
POMAGMA_ASSERT4(not Rx_bit, "double insertion: " << lhs << "," << rhs);
Rx_bit.one();
}
// policy: callback whenever i~k but not j~k
void BinaryRelation::unsafe_merge (Ob i)
{
Ob j = carrier().find(i);
POMAGMA_ASSERT4(j < i, "BinaryRelation tried to merge item with self");
DenseSet diff(item_dim());
DenseSet rep(item_dim(), nullptr);
DenseSet dep(item_dim(), nullptr);
// merge rows (i, _) into (j, _)
dep.init(m_lines.Lx(i));
_remove_Rx(i, dep);
rep.init(m_lines.Lx(j));
if (rep.merge(dep, diff)) {
for (auto k = diff.iter(); k.ok(); k.next()) {
_insert_Rx(j, *k);
}
}
// merge cols (_, i) into (_, j)
dep.init(m_lines.Rx(i));
_remove_Lx(dep, i);
rep.init(m_lines.Rx(j));
if (rep.merge(dep, diff)) {
for (auto k = diff.iter(); k.ok(); k.next()) {
_insert_Lx(*k, j);
}
}
}
Intersection(size_t item_dim, init_t words)
: m_word_dim(items_to_words(item_dim)), m_words(words) {
static_assert(rank >= 2, "rank must be at least 2");
POMAGMA_ASSERT3(
words.size() == rank,
"constructed Intersection with wrong number of arguments");
for (size_t i = 0; i < rank; ++i) {
POMAGMA_ASSERT4(m_words[i],
"constructed Intersection with null words" << i);
}
}
void NullaryFunction::unsafe_merge (Ob dep)
{
UniqueLock lock(m_mutex);
Ob rep = m_carrier.find(dep);
POMAGMA_ASSERT4(rep < dep, "bad merge: " << dep << "," << rep);
POMAGMA_ASSERT_RANGE_(4, dep, support().item_dim());
POMAGMA_ASSERT_RANGE_(4, rep, support().item_dim());
if (m_value == dep) {
m_value = rep;
}
}
void BinaryFunction::unsafe_merge(const Ob dep) {
POMAGMA_ASSERT5(support().contains(dep), "unsupported dep: " << dep);
Ob rep = carrier().find(dep);
POMAGMA_ASSERT5(support().contains(rep), "unsupported rep: " << rep);
POMAGMA_ASSERT4(rep != dep, "self merge: " << dep << "," << rep);
// Note: in some cases, triples may move multiple times, e.g.
// (dep, dep) --> (dep, rep) --> (rep, rep)
// dep as rhs
for (auto iter = iter_rhs(dep); iter.ok(); iter.next()) {
Ob lhs = *iter;
auto dep_iter = m_values.find(std::make_pair(lhs, dep));
Ob dep_val = dep_iter->second;
m_values.erase(dep_iter);
m_lines.Lx(lhs, dep).zero();
Ob& rep_val = m_values[std::make_pair(lhs, rep)];
if (carrier().set_or_merge(rep_val, dep_val)) {
m_lines.Lx(lhs, rep).one();
}
}
{
DenseSet dep_set(item_dim(), m_lines.Rx(dep));
DenseSet rep_set(item_dim(), m_lines.Rx(rep));
rep_set.merge(dep_set);
}
// dep as lhs
rep = carrier().find(rep);
for (auto iter = iter_lhs(dep); iter.ok(); iter.next()) {
Ob rhs = *iter;
auto dep_iter = m_values.find(std::make_pair(dep, rhs));
Ob dep_val = dep_iter->second;
m_values.erase(dep_iter);
m_lines.Rx(dep, rhs).zero();
Ob& rep_val = m_values[std::make_pair(rep, rhs)];
if (carrier().set_or_merge(rep_val, dep_val)) {
m_lines.Rx(rep, rhs).one();
}
}
{
DenseSet dep_set(item_dim(), m_lines.Lx(dep));
DenseSet rep_set(item_dim(), m_lines.Lx(rep));
rep_set.merge(dep_set);
}
// values must be updated in batch by update_values
}
void SymmetricFunction::unsafe_merge(const Ob dep) {
POMAGMA_ASSERT5(support().contains(dep), "unsupported dep: " << dep);
Ob rep = carrier().find(dep);
POMAGMA_ASSERT5(support().contains(rep), "unsupported rep: " << rep);
POMAGMA_ASSERT4(rep != dep, "self merge: " << dep << "," << rep);
// (dep, dep) -> (rep, rep)
if (defined(dep, dep)) {
auto dep_iter = m_values.find(std::make_pair(dep, dep));
Ob dep_val = dep_iter->second;
m_values.erase(dep_iter);
m_lines.Lx(dep, dep).zero();
Ob& rep_val = m_values[std::make_pair(rep, rep)];
if (carrier().set_or_merge(rep_val, dep_val)) {
m_lines.Lx(rep, rep).one();
}
}
// (dep, rhs) --> (rep, rhs) for rhs != dep
rep = carrier().find(rep);
for (auto iter = iter_lhs(dep); iter.ok(); iter.next()) {
Ob rhs = *iter;
auto dep_iter = m_values.find(make_sorted_pair(dep, rhs));
Ob dep_val = dep_iter->second;
m_values.erase(dep_iter);
m_lines.Rx(dep, rhs).zero();
Ob& rep_val = m_values[make_sorted_pair(rep, rhs)];
if (carrier().set_or_merge(rep_val, dep_val)) {
m_lines.Rx(rep, rhs).one();
}
}
DenseSet dep_set(item_dim(), m_lines.Lx(dep));
DenseSet rep_set(item_dim(), m_lines.Lx(rep));
rep_set.merge(dep_set);
// values must be updated in batch by update_values
}
inline void dense_set::remove (size_t i)
{
POMAGMA_ASSERT4(contains(i), "double removal: " << i);
_bit(i).zero();
}
inline void dense_set::insert (size_t i)
{
POMAGMA_ASSERT4(not contains(i), "double insertion: " << i);
_bit(i).one();
}
