gcc/libitm/aatree.h

216 lines
4.9 KiB
C++

/* Copyright (C) 2009, 2011 Free Software Foundation, Inc.
Contributed by Richard Henderson <rth@redhat.com>.
This file is part of the GNU Transactional Memory Library (libitm).
Libitm is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
Libitm 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 General Public License for
more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
/* Implements an AA tree (http://en.wikipedia.org/wiki/AA_tree) with an
integer key, and data attached to the node via flexible array member. */
#ifndef LIBITM_AATREE_H
#define LIBITM_AATREE_H 1
namespace GTM HIDDEN {
template<typename KEY> class aa_tree_key;
class aa_node_base
{
public:
static const bool L = false;
static const bool R = true;
private:
typedef unsigned int level_type;
aa_node_base *m_link[2];
level_type m_level;
static const aa_node_base s_nil;
public:
aa_node_base(level_type l = 1)
: m_link { const_cast<aa_node_base *>(&s_nil),
const_cast<aa_node_base *>(&s_nil) },
m_level(l)
{ }
bool is_nil() const { return this == &s_nil; }
aa_node_base * link(bool d) { return m_link[d]; }
void set_link(bool d, aa_node_base *val) { m_link[d] = val; }
aa_node_base *skew();
aa_node_base *split();
void decrease_level();
static void *operator new (size_t s) { return xmalloc (s); }
static void operator delete (void *p) { free (p); }
};
template<typename KEY>
struct aa_node_key : public aa_node_base
{
typedef aa_node_base base;
KEY key;
explicit aa_node_key(KEY k) : key(k) { }
aa_node_key * link(bool d)
{
return static_cast<aa_node_key *>(base::link(d));
}
aa_node_key *skew() { return static_cast<aa_node_key *>(base::skew()); }
aa_node_key *split() { return static_cast<aa_node_key *>(base::split()); }
};
template<typename KEY, typename DATA>
struct aa_node : public aa_node_key<KEY>
{
typedef aa_node_key<KEY> base;
DATA data;
explicit aa_node(KEY k) : base(k) { }
aa_node * link(bool d)
{
return static_cast<aa_node *>(base::link(d));
}
};
template<typename KEY>
class aa_tree_key
{
public:
typedef aa_node_key<KEY> node;
typedef node *node_ptr;
protected:
node_ptr m_tree;
protected:
aa_tree_key() : m_tree(0) { }
node_ptr find(KEY k) const;
static node_ptr insert_1 (node_ptr t, node_ptr n);
void insert(node_ptr n);
static node_ptr erase_1 (node_ptr t, KEY k, node_ptr *pfree);
node_ptr erase(KEY k);
};
extern template class aa_tree_key<uintptr_t>;
template<typename KEY, typename DATA>
class aa_tree : public aa_tree_key<KEY>
{
public:
typedef aa_tree_key<KEY> base;
typedef aa_node<KEY, DATA> node;
typedef node *node_ptr;
typedef void (*trav_callback)(KEY, DATA *, void *);
private:
static void clear_1 (node_ptr);
static void traverse_1 (node_ptr, trav_callback, void *);
public:
aa_tree() = default;
~aa_tree() { clear(); }
static void *operator new (size_t s, aa_tree<KEY, DATA>* p) { return p; }
DATA *find(KEY k) const
{
node_ptr n = static_cast<node_ptr>(base::find (k));
return n ? &n->data : 0;
}
DATA *insert(KEY k)
{
node_ptr n = new node(k);
base::insert(n);
return &n->data;
}
void erase(KEY k)
{
node_ptr n = static_cast<node_ptr>(base::erase (k));
delete n;
}
node_ptr remove(KEY k, DATA** data)
{
node_ptr n = static_cast<node_ptr>(base::erase (k));
*data = (n ? &n->data : 0);
return n;
}
void clear()
{
node_ptr n = static_cast<node_ptr>(this->m_tree);
if (n)
{
this->m_tree = 0;
clear_1 (n);
}
}
void traverse (trav_callback cb, void *cb_data)
{
node_ptr t = static_cast<node_ptr>(this->m_tree);
if (t != 0)
traverse_1 (t, cb, cb_data);
}
};
template<typename KEY, typename DATA>
void
aa_tree<KEY, DATA>::clear_1 (node_ptr t)
{
if (t->is_nil())
return;
clear_1 (t->link(node::L));
clear_1 (t->link(node::R));
delete t;
}
template<typename KEY, typename DATA>
void
aa_tree<KEY, DATA>::traverse_1 (node_ptr t, trav_callback cb, void *cb_data)
{
if (t->is_nil())
return;
cb (t->key, &t->data, cb_data);
traverse_1 (t->link(node::L), cb, cb_data);
traverse_1 (t->link(node::R), cb, cb_data);
}
} // namespace GTM
#endif // LIBITM_AATREE_H