[subtracting_span_iterator] recode using run_set

persistent-data/space-maps/careful_alloc.cc

@@ -71,7 +71,7 @@ namespace {
 		}
 
 		virtual maybe_block find_free(span_iterator &it) {
-			subtracting_span_iterator filtered_it(it, freed_blocks_);
+			subtracting_span_iterator filtered_it(get_nr_blocks(), it, freed_blocks_);
 			return sm_->find_free(filtered_it);
 		}
 
@@ -109,11 +109,11 @@ namespace {
 		}
 
 		void mark_freed(block_address b) {
-			freed_blocks_.insert(b);
+			freed_blocks_.add(b, b + 1);
 		}
 
 		bool was_freed(block_address b) const {
-			return freed_blocks_.count(b) > 0;
+			return freed_blocks_.member(b) > 0;
 		}
 
 		checked_space_map::ptr sm_;

persistent-data/space-maps/recursive.cc

@@ -129,7 +129,7 @@ namespace {
 		find_free(span_iterator &it) {
 			recursing_lock lock(*this);
 
-			subtracting_span_iterator filtered_it(it, allocated_blocks_);
+			subtracting_span_iterator filtered_it(get_nr_blocks(), it, allocated_blocks_);
 			return sm_->find_free(filtered_it);
 		}
 
@@ -240,7 +240,7 @@ namespace {
 			ops_[op.b_].push_back(op);
 
 			if (op.op_ == block_op::INC || (op.op_ == block_op::SET && op.rc_ > 0))
-				allocated_blocks_.insert(op.b_);
+				allocated_blocks_.add(op.b_, op.b_ + 1);
 		}
 
 		void cant_recurse(string const &method) const {

persistent-data/space-maps/subtracting_span_iterator.h

@@ -2,98 +2,60 @@
 #define SPAN_ITERATOR_H
 
 #include "persistent-data/space_map.h"
+#include "persistent-data/run_set.h"
 
 #include <set>
 
 //----------------------------------------------------------------
 
 namespace persistent_data {
-	// FIXME: rewrite with tests using the run_list stuff.
 	class subtracting_span_iterator : public space_map::span_iterator {
 	public:
-		typedef set<block_address> block_set;
+		typedef typename base::run_set<block_address> block_set;
 		typedef space_map::span span;
 
-		subtracting_span_iterator(span_iterator &sub_it,
+		subtracting_span_iterator(block_address max,
+					  span_iterator &sub_it,
 					  block_set const &forbidden_blocks)
-			: sub_it_(sub_it),
-			  forbidden_blocks_(forbidden_blocks),
-			  current_begin_() {
+			: max_(max) {
+			for (maybe_span ms = sub_it.first(); ms; ms = sub_it.next())
+				runs_.add(ms->first, ms->second);
+
+			block_set bs(forbidden_blocks);
+			runs_.negate();
+			runs_.merge(bs);
+			runs_.negate();
 		}
 
 		virtual maybe_span first() {
-			current_span_ = sub_it_.first();
-
-			if (current_span_)
-				current_begin_ = current_span_->first;
-
-			return next();
+			current_ = runs_.begin();
+			return get_current();
 		}
 
 		virtual maybe_span next() {
-			maybe_span r;
+			if (current_ != runs_.end())
+				++current_;
 
-			while (more_spans()) {
-				r = next_();
-				if (r)
-					break;
-			}
-
-			return r;
+			return get_current();
 		}
 
 	private:
-		bool more_spans() const {
-			return current_span_;
+		maybe_span get_current() {
+			// FIXME: unsafe deref of begin and end
+			return (current_ == runs_.end()) ?
+				maybe_span() :
+				maybe_span(std::make_pair(maybe_default(current_->begin_, 0ULL),
+							  maybe_default(current_->end_, max_)));
 		}
 
-		bool span_consumed() const {
-			return current_begin_ == current_span_->second;
+		typedef boost::optional<block_address> maybe;
+		static block_address maybe_default(maybe const &m, block_address default_) {
+			return m ? *m : default_;
 		}
 
-		bool forbidden_block(block_address b) const {
-			return forbidden_blocks_.count(b) > 0;
-		}
-
-		void skip_forbidden_blocks() {
-			while (!span_consumed() && forbidden_block(current_begin_))
-				current_begin_++;
-		}
-
-		span get_span() {
-			block_address b = current_begin_;
-
-			while (!span_consumed() && !forbidden_block(current_begin_))
-				current_begin_++;
-
-			return span(b, current_begin_);
-		}
-
-		void get_current_span_from_sub_it() {
-			current_span_ = sub_it_.next();
-			if (current_span_)
-				current_begin_ = current_span_->first;
-		}
-
-		maybe_span next_() {
-			if (span_consumed())
-				get_current_span_from_sub_it();
-
-			if (!more_spans())
-				return maybe_span();
-
-			skip_forbidden_blocks();
-
-			if (!span_consumed())
-				return maybe_span(get_span());
-			else
-				return maybe_span();
-		}
-
-		span_iterator &sub_it_;
-		block_set const &forbidden_blocks_;
-		maybe_span current_span_;
-		block_address current_begin_;
+		block_address max_;
+		block_set runs_;
+		block_set::const_iterator current_;
 	};
 }