size_t num_tasks() {
size_t n = 0;
for(vid_t i=0; i < curiteration_bitset->size(); i++) {
n += curiteration_bitset->get(i);
}
return n;
}
inline void add_task(vid_t vertex, bool also_this_iteration=false) {
nextiteration_bitset->set_bit(vertex);
if (also_this_iteration) {
// If possible, add to schedule already this iteration
curiteration_bitset->set_bit(vertex);
}
has_new_tasks = true;
}
dense_bitset operator-(const dense_bitset& other) const {
ASSERT_EQ(size(), other.size());
dense_bitset ret(size());
for (size_t i = 0; i < arrlen; ++i) {
ret.array[i] = array[i] - (array[i] & other.array[i]);
}
return ret;
}
void new_iteration(int iteration) {
if (iteration > 0) {
// Swap
dense_bitset * tmp = curiteration_bitset;
curiteration_bitset = nextiteration_bitset;
nextiteration_bitset = tmp;
nextiteration_bitset->clear();
}
}
size_t operator++(int){
size_t prevpos = pos;
if (db->next_bit(pos) == false) pos = (size_t)(-1);
return prevpos;
}
size_t operator++(){
if (db->next_bit(pos) == false) pos = (size_t)(-1);
return pos;
}
void resize(vid_t maxsize) {
bitset.resize(maxsize);
}
/**
* Resize the internal locks for a different graph
*/
void resize(size_t num_vertices) {
atomic_box_vec.resize(num_vertices);
atomic_box_vec.clear();
}
void clear(size_t i) { atomic_box_vec.clear_bit(i);}
size_t size() const {
return atomic_box_vec.size();
}
bool peek(const size_t& idx,
value_type& ret_val) {
return atomic_box_vec.get(idx);
}
bool empty() {
return (vertex_is_scheduled.popcount() == 0);
}
void add_task_to_all() {
has_new_tasks = true;
bitset.setall();
}
void remove_tasks(vid_t fromvertex, vid_t tovertex) {
bitset.clear_bits(fromvertex, tovertex);
}
inline void remove_task(vid_t vertex) {
bitset.clear_bit(vertex);
}
inline bool is_scheduled(vid_t vertex) {
return bitset.get(vertex);
}
bool test_and_get(const size_t& idx,
value_type& ret_val) {
return atomic_box_vec.clear_bit(idx);
}
void resize(vid_t maxsize) {
curiteration_bitset->resize(maxsize);
nextiteration_bitset->resize(maxsize);
}
bool empty(const size_t& idx) const {
return !atomic_box_vec.get(idx);
}
inline bool is_scheduled(vid_t vertex) {
return curiteration_bitset->get(vertex);
}
void clear() {
atomic_box_vec.clear();
}
void remove_tasks(vid_t fromvertex, vid_t tovertex) {
nextiteration_bitset->clear_bits(fromvertex, tovertex);
}
/** Initialize the per vertex task set */
atomic_add_vector2(size_t num_vertices = 0) {
resize(num_vertices);
atomic_box_vec.clear();
}
void add_task_to_all() {
has_new_tasks = true;
curiteration_bitset->setall();
}
/** Add a task to the set returning false if the task was already
present. */
bool add(const size_t& idx,
const value_type& val) {
return !atomic_box_vec.set_bit(idx);
} // end of add task to set
inline void add_task(vid_t vertex) {
bitset.set_bit(vertex);
has_new_tasks = true;
}
