Changeset 3174

Timestamp:

Mar 8, 2014, 3:51:20 PM (9 years ago)

Author:

Peter

Message:

#refs 784

Speed up copy and assignment by keeping pointers of maps rather than
hard copies. Incrementing input iterators is expected to [possibly]
modify underlying resource. Take istream_iterator as an example, which
obviously modifies the istream it points to when it's incremented and
thus effects other iterators that point to the same istream. This is
described in concept description as that input iterators are only
guaranteed to be a single pass iterator. Given that users do not
expect input iterators to be independent, we can use that to speed up
copy constructor by only copiding a [smart] pointer rather than the
whole map, which might get quite heavy if there are a lot of pairs
mapped far away from each other.

File:

• trunk/yat/omic/BamPairIterator.h (modified) (7 diffs)

trunk/yat/omic/BamPairIterator.h

@@ -29 +29 @@
 #include <boost/concept/assert.hpp>
 #include <boost/iterator/iterator_facade.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include <iterator>
@@ -51 +52 @@
      stepping until it finds a read whose mate it has already seen, and
      operator* return the pair of BamReads.
+
+     Note that BamPairIterator is a single-pass iterator, i.e., once it
+     is incremented the behaviour of its copies is undefined.
    */
   template<typename Base>
@@ -78 +82 @@
     Base end_;
     std::pair<BamRead, BamRead> x_;
-    std::map<std::string, BamRead> siam_reads_;
+    boost::shared_ptr<std::map<std::string, BamRead> > siam_reads_;
     typedef std::pair<int32_t, int32_t> Position;
-    std::multimap<Position, BamRead> reads_;
+    boost::shared_ptr<std::multimap<Position, BamRead> > reads_;
     friend class boost::iterator_core_access;
 
@@ -116 +120 @@
   template<typename Base>
   BamPairIterator<Base>::BamPairIterator(Base base, Base end)
-    : iter_(base), end_(end)
+    : iter_(base), end_(end),
+      siam_reads_(new std::map<std::string, BamRead>),
+      reads_(new std::multimap<Position, BamRead>)
   {
     BOOST_CONCEPT_ASSERT((boost::InputIterator<Base>));
@@ -167 +173 @@
       Position mate_position(iter_->mtid(), iter_->mpos());
       // clear siam reads if iter is more advanced than siam reads
-      if (siam_reads_.size() && less(siam_reads_.begin()->second, *iter_))
-        siam_reads_.clear();
+      if (siam_reads_->size() && less(siam_reads_->begin()->second, *iter_))
+        siam_reads_->clear();
 
       // have not seen mate yet
       if (mate_position > position)
-        reads_.insert(std::make_pair(mate_position, *iter_));
+        reads_->insert(std::make_pair(mate_position, *iter_));
       else if (position > mate_position) {
         std::multimap<Position, BamRead>::iterator
-          lower = reads_.lower_bound(position);
+          lower = reads_->lower_bound(position);
         // erase all reads with mate position less than current
         // position (assuming input range is sorted)
-        reads_.erase(reads_.begin(), lower);
+        reads_->erase(reads_->begin(), lower);
 
         // find mate and assign pair
-        for (; lower!=reads_.end() && lower->first == position; ++lower)
+        for (; lower!=reads_->end() && lower->first == position; ++lower)
           if (same_query_name(lower->second, *iter_)) {
             x_.first = lower->second;
@@ -191 +197 @@
         // check if we have already seen mate and stored it in map
         std::map<std::string, BamRead>::iterator
-          mate = siam_reads_.lower_bound(iter_->name());
-        if (mate!=siam_reads_.end() && same_query_name(mate->second, *iter_)) {
+          mate = siam_reads_->lower_bound(iter_->name());
+        if (mate!=siam_reads_->end() && same_query_name(mate->second, *iter_)) {
           x_.first = mate->second;
           x_.second = *iter_;
@@ -199 +205 @@
         else
           // insert with hint
-          siam_reads_.insert(mate, std::make_pair(iter_->name(), *iter_));
+          siam_reads_->insert(mate, std::make_pair(iter_->name(), *iter_));
       }
     }