DM-52370: Migrated partitioner from boost::shared_ptr to std::shared_ptr

Author: iagaponenko

src/partition/ChunkReducer.cc

@@ -27,8 +27,6 @@
 #include <stdexcept>
 #include <string>
 
-#include "boost/make_shared.hpp"
-
 #include "partition/ConfigStore.h"
 
 namespace fs = boost::filesystem;
@@ -37,7 +35,7 @@ namespace po = boost::program_options;
 namespace lsst::partition {
 
 ChunkReducer::ChunkReducer(ConfigStore const& config)
-        : _index(boost::make_shared<ChunkIndex>()),
+        : _index(std::make_shared<ChunkIndex>()),
           _chunkId(-1),
           _numNodes(config.get<uint32_t>("out.num-nodes")),
           _prefix(config.get<std::string>("part.prefix").c_str()),  // defend against GCC PR21334

src/partition/ChunkReducer.h

@@ -23,10 +23,10 @@
 #ifndef LSST_PARTITION_CHUNKREDUCER_H
 #define LSST_PARTITION_CHUNKREDUCER_H
 
+#include <memory>
 #include <stdint.h>
 
 #include "boost/filesystem/path.hpp"
-#include "boost/shared_ptr.hpp"
 
 #include "Chunker.h"
 #include "ChunkIndex.h"
@@ -57,12 +57,12 @@ class ChunkReducer : public WorkerBase<ChunkLocation, ChunkIndex> {
     void reduce(RecordIter const begin, RecordIter const end);
     void finish();
 
-    boost::shared_ptr<ChunkIndex> const result() { return _index; }
+    std::shared_ptr<ChunkIndex> const result() { return _index; }
 
 private:
     void _makeFilePaths(int32_t chunkId);
 
-    boost::shared_ptr<ChunkIndex> _index;
+    std::shared_ptr<ChunkIndex> _index;
     int32_t _chunkId;
     uint32_t _numNodes;
     std::string _prefix;

src/partition/InputLines.cc

@@ -25,7 +25,6 @@
 #include <cstdlib>
 #include <stdexcept>
 
-#include "boost/make_shared.hpp"
 #include "boost/static_assert.hpp"
 #include "boost/thread.hpp"
 #include "boost/algorithm/string/predicate.hpp"
@@ -85,11 +84,11 @@ struct LineFragment {
 
 // An input file block.
 struct Block {
-    boost::shared_ptr<InputFile> file;
+    std::shared_ptr<InputFile> file;
     off_t offset;
     size_t size;
-    boost::shared_ptr<LineFragment> head;
-    boost::shared_ptr<LineFragment> tail;
+    std::shared_ptr<LineFragment> head;
+    std::shared_ptr<LineFragment> tail;
 
     Block() : file(), offset(0), size(0), head(), tail() {}
 
@@ -180,7 +179,7 @@ std::vector<Block> const split(fs::path const &path, off_t blockSize) {
 
     if (boost::algorithm::ends_with(path.c_str(), ".parquet") ||
         boost::algorithm::ends_with(path.c_str(), ".parq")) {
-        b.file = boost::make_shared<InputFileArrow>(path, blockSize);
+        b.file = std::make_shared<InputFileArrow>(path, blockSize);
 
         b.size = blockSize;
         fileSize = b.file->getBatchNumber();
@@ -194,7 +193,7 @@ std::vector<Block> const split(fs::path const &path, off_t blockSize) {
         return blocks;
     }
 
-    b.file = boost::make_shared<InputFile>(path);
+    b.file = std::make_shared<InputFile>(path);
 
     b.size = blockSize;
     fileSize = b.file->size();
@@ -208,7 +207,7 @@ std::vector<Block> const split(fs::path const &path, off_t blockSize) {
         b.size = static_cast<size_t>(std::min(fileSize - b.offset, blockSize));
         b.head = b.tail;
         if (i < numBlocks - 1) {
-            b.tail = boost::make_shared<LineFragment>();
+            b.tail = std::make_shared<LineFragment>();
         } else {
             b.tail.reset();
         }
@@ -325,11 +324,11 @@ CharPtrPair const InputLines::Impl::read(char *buf) {
 // Method delegation.
 
 InputLines::InputLines(std::vector<fs::path> const &paths, size_t blockSize, bool skipFirstLine)
-        : _impl(boost::make_shared<Impl>(paths, blockSize, skipFirstLine)) {}
+        : _impl(std::make_shared<Impl>(paths, blockSize, skipFirstLine)) {}
 
 InputLines::InputLines(std::vector<fs::path> const &paths, size_t blockSize, bool skipFirstLine,
                        ConfigParamArrow const &configArrow)
-        : _impl(boost::make_shared<Impl>(paths, blockSize, skipFirstLine, configArrow)) {}
+        : _impl(std::make_shared<Impl>(paths, blockSize, skipFirstLine, configArrow)) {}
 
 size_t InputLines::getBlockSize() const { return _impl ? _impl->getBlockSize() : 0; }
 

src/partition/InputLines.h

@@ -25,13 +25,13 @@
 /// \file
 /// \brief A class for reading lines from a set of text files in parallel.
 
+#include <memory>
 #include <sys/types.h>
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
 #include "boost/filesystem.hpp"
-#include "boost/shared_ptr.hpp"
 
 // Qserv headers
 #include "partition/ParquetInterface.h"
@@ -97,7 +97,7 @@ class InputLines {
 private:
     class Impl;
 
-    boost::shared_ptr<Impl> _impl;
+    std::shared_ptr<Impl> _impl;
 };
 
 }  // namespace lsst::partition

src/partition/MapReduce.h

@@ -26,20 +26,19 @@
 #ifndef LSST_PARTITION_MAPREDUCE_H
 #define LSST_PARTITION_MAPREDUCE_H
 
-#include <sys/types.h>
-#include <stdint.h>
+#include <algorithm>
 #include <cstdlib>
 #include <cstring>
-#include <algorithm>
+#include <memory>
+#include <sys/types.h>
 #include <stdexcept>
+#include <stdint.h>
 #include <vector>
 
 #include "boost/filesystem.hpp"
-#include "boost/make_shared.hpp"
 #include "boost/program_options.hpp"
 #include "boost/ref.hpp"
 #include "boost/scoped_array.hpp"
-#include "boost/shared_ptr.hpp"
 #include "boost/thread.hpp"
 
 #include "partition/ConfigStore.h"
@@ -271,7 +270,7 @@ void Silo<K>::_grow() {
 /// After all input has been read, mapped and reduced, each worker
 /// is asked for a result via:
 ///
-///     boost::shared_ptr<Result> const result();
+///     std::shared_ptr<Result> const result();
 ///
 /// The `Result` type must provide the following method:
 ///
@@ -305,7 +304,7 @@ namespace detail {
 /// Comparator for shared pointers to `Silo`s.
 template <typename K>
 struct SiloPtrCmp {
-    bool operator()(boost::shared_ptr<Silo<K> > const &s, boost::shared_ptr<Silo<K> > const &t) const {
+    bool operator()(std::shared_ptr<Silo<K> > const &s, std::shared_ptr<Silo<K> > const &t) const {
         return *s < *t;
     }
 };
@@ -357,7 +356,7 @@ class JobBase {
     typedef detail::SortedRecordRange<Key> SortedRecordRange;
     typedef typename SortedRecordRange::RecordIter RecordIter;
     typedef partition::Silo<Key> Silo;
-    typedef boost::shared_ptr<Silo> SiloPtr;
+    typedef std::shared_ptr<Silo> SiloPtr;
     typedef detail::SiloPtrCmp<Key> SiloPtrCmp;
     typedef typename std::vector<SiloPtr>::const_iterator SiloPtrIter;
 
@@ -440,7 +439,7 @@ void JobBase<DerivedT, WorkerT>::run(InputLines input) {
     std::vector<SiloPtr> silos;
     silos.reserve(_numWorkers);
     for (uint32_t i = 0; i < _numWorkers; ++i) {
-        silos.push_back(boost::make_shared<Silo>());
+        silos.push_back(std::make_shared<Silo>());
     }
     _silos.swap(silos);
     _input = input;
@@ -504,8 +503,8 @@ void JobBase<DerivedT, WorkerT>::defineOptions(boost::program_options::options_d
 template <typename DerivedT, typename WorkerT>
 void JobBase<DerivedT, WorkerT>::_work() {
     // Pre-allocate disk read buffer.
-    boost::shared_ptr<char> buffer(static_cast<char *>(std::malloc(_input.getMinimumBufferCapacity())),
-                                   std::free);
+    std::shared_ptr<char> buffer(static_cast<char *>(std::malloc(_input.getMinimumBufferCapacity())),
+                                 std::free);
     if (!buffer) {
         throw std::bad_alloc();
     }
@@ -652,30 +651,30 @@ class JobImpl : private JobBase<JobImpl<WorkerT, ResultT>, WorkerT> {
     typedef JobBase<JobImpl<WorkerT, ResultT>, WorkerT> Base;
 
     void _storeResult(WorkerT &w) {
-        boost::shared_ptr<ResultT> r = w.result();
+        std::shared_ptr<ResultT> r = w.result();
         if (!_result) {
             _result = r;
         } else if (r) {
             _result->merge(*r);
         }
     }
 
-    boost::shared_ptr<ResultT> _result;
+    std::shared_ptr<ResultT> _result;
 
     // Allow JobBase to call _storeResult.
     friend class JobBase<JobImpl<WorkerT, ResultT>, WorkerT>;
 
 public:
     explicit JobImpl(ConfigStore const &config) : Base(config) {}
 
-    boost::shared_ptr<ResultT> const run(InputLines input) {
+    std::shared_ptr<ResultT> const run(InputLines input) {
         try {
             Base::run(input);
         } catch (...) {
             _result.reset();
             throw;
         }
-        boost::shared_ptr<ResultT> r;
+        std::shared_ptr<ResultT> r;
         r.swap(_result);
         return r;
     }
@@ -711,7 +710,7 @@ class JobImpl<WorkerT, void> : private JobBase<JobImpl<WorkerT, void>, WorkerT>
 ///
 /// Otherwise, it is:
 ///
-///     boost::shared_ptr<typename WorkerT::Result> const run(InputLines input);
+///     std::shared_ptr<typename WorkerT::Result> const run(InputLines input);
 ///
 /// Multiple calls to `run` with different inputs are perfectly legal, and `run`
 /// provides the strong exception safety guarantee, at least as far as in-memory

src/partition/sph-duplicate.cc

@@ -28,14 +28,14 @@
 #include <functional>
 #include <iostream>
 #include <limits>
+#include <memory>
 #include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "boost/filesystem.hpp"
 #include "boost/program_options.hpp"
-#include "boost/shared_ptr.hpp"
 
 #include "partition/Chunker.h"
 #include "partition/ChunkReducer.h"
@@ -58,7 +58,7 @@ class Duplicator {
 public:
     Duplicator() : _blockSize(0), _level(-1) {}
 
-    boost::shared_ptr<ChunkIndex> const run(ConfigStore const& config);
+    std::shared_ptr<ChunkIndex> const run(ConfigStore const& config);
 
 private:
     // A list of (HTM triangle, chunk ID) pairs.
@@ -70,9 +70,9 @@ class Duplicator {
     InputLines const _makeInput() const;
 
     TargetMap _targets;
-    boost::shared_ptr<Chunker> _chunker;
-    boost::shared_ptr<HtmIndex> _partIndex;
-    boost::shared_ptr<HtmIndex> _index;
+    std::shared_ptr<Chunker> _chunker;
+    std::shared_ptr<HtmIndex> _partIndex;
+    std::shared_ptr<HtmIndex> _index;
     fs::path _partIndexDir;
     fs::path _indexDir;
     size_t _blockSize;
@@ -249,8 +249,8 @@ class Worker : public ChunkReducer {
     std::vector<ChunkLocation> _locations;
     fs::path _partIndexDir;
     fs::path _indexDir;
-    boost::shared_ptr<LessThanCounter> _partIdsLessThan;
-    boost::shared_ptr<LessThanCounter> _idsLessThan;
+    std::shared_ptr<LessThanCounter> _partIdsLessThan;
+    std::shared_ptr<LessThanCounter> _idsLessThan;
 };
 
 Worker::Worker(ConfigStore const& config)
@@ -525,13 +525,13 @@ void Worker::defineOptions(po::options_description& opts) {
 
 typedef Job<Worker> DuplicateJob;
 
-boost::shared_ptr<ChunkIndex> const Duplicator::run(ConfigStore const& config) {
+std::shared_ptr<ChunkIndex> const Duplicator::run(ConfigStore const& config) {
     // Initialize state.
-    boost::shared_ptr<Chunker> chunker(new Chunker(config));
+    std::shared_ptr<Chunker> chunker(new Chunker(config));
     std::vector<int32_t> chunks = chunksToDuplicate(*chunker, config);
     _chunker.swap(chunker);
     DuplicateJob job(config);
-    boost::shared_ptr<ChunkIndex> chunkIndex;
+    std::shared_ptr<ChunkIndex> chunkIndex;
     if (!config.has("id") && !config.has("part.id")) {
         throw std::runtime_error(
                 "One or both of the --id and --part.id "
@@ -575,7 +575,7 @@ boost::shared_ptr<ChunkIndex> const Duplicator::run(ConfigStore const& config) {
         chunks.pop_back();
         --n;
         if (n == 0 || chunks.empty()) {
-            boost::shared_ptr<ChunkIndex> c = job.run(_makeInput());
+            std::shared_ptr<ChunkIndex> c = job.run(_makeInput());
             if (c) {
                 if (chunkIndex) {
                     chunkIndex->merge(*c);
@@ -606,7 +606,7 @@ int main(int argc, char const* const* argv) {
         part::ensureOutputFieldExists(config, "part.chunk");
         part::ensureOutputFieldExists(config, "part.sub-chunk");
         part::makeOutputDirectory(config, true);
-        boost::shared_ptr<part::ChunkIndex> index = part::duplicator.run(config);
+        std::shared_ptr<part::ChunkIndex> index = part::duplicator.run(config);
         if (!index->empty()) {
             fs::path d(config.get<std::string>("out.dir"));
             fs::path f = config.get<std::string>("part.prefix") + "_index.bin";

src/partition/sph-estimate-stats.cc

@@ -25,13 +25,13 @@
 ///        counts for the data-sets generated by the duplicator.
 
 #include <iostream>
+#include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
 
 #include "boost/filesystem.hpp"
 #include "boost/program_options.hpp"
-#include "boost/shared_ptr.hpp"
 
 #include "partition/Chunker.h"
 #include "partition/ChunkIndex.h"
@@ -85,11 +85,11 @@ void defineOptions(po::options_description& opts) {
     defineOutputOptions(opts);
 }
 
-boost::shared_ptr<ChunkIndex> const estimateStats(std::vector<int32_t> const& chunks, Chunker const& chunker,
-                                                  HtmIndex const& index, HtmIndex const& partIndex) {
+std::shared_ptr<ChunkIndex> const estimateStats(std::vector<int32_t> const& chunks, Chunker const& chunker,
+                                                HtmIndex const& index, HtmIndex const& partIndex) {
     std::vector<int32_t> subChunks;
     std::vector<uint32_t> htmIds;
-    boost::shared_ptr<ChunkIndex> chunkIndex(new ChunkIndex());
+    std::shared_ptr<ChunkIndex> chunkIndex(new ChunkIndex());
     // loop over chunks
     for (std::vector<int32_t>::size_type i = 0; i < chunks.size(); ++i) {
         int32_t chunkId = chunks[i];
@@ -126,7 +126,7 @@ boost::shared_ptr<ChunkIndex> const estimateStats(std::vector<int32_t> const& ch
     return chunkIndex;
 }
 
-boost::shared_ptr<ChunkIndex> const estimateStats(ConfigStore const& config) {
+std::shared_ptr<ChunkIndex> const estimateStats(ConfigStore const& config) {
     Chunker chunker(config);
     if (!config.has("index") && !config.has("part.index")) {
         throw std::runtime_error(
@@ -138,8 +138,8 @@ boost::shared_ptr<ChunkIndex> const estimateStats(ConfigStore const& config) {
     fs::path indexPath(config.get<std::string>(opt));
     opt = (config.has("part.index") ? "part.index" : "index");
     fs::path partIndexPath(config.get<std::string>(opt));
-    boost::shared_ptr<HtmIndex> index(new HtmIndex(indexPath));
-    boost::shared_ptr<HtmIndex> partIndex;
+    std::shared_ptr<HtmIndex> index(new HtmIndex(indexPath));
+    std::shared_ptr<HtmIndex> partIndex;
     if (partIndexPath != indexPath) {
         partIndex.reset(new HtmIndex(partIndexPath));
     } else {
@@ -173,7 +173,7 @@ int main(int argc, char const* const* argv) {
         part::defineOptions(options);
         part::ConfigStore config = part::parseCommandLine(options, argc, argv, help);
         part::makeOutputDirectory(config, true);
-        boost::shared_ptr<part::ChunkIndex> index = part::estimateStats(config);
+        std::shared_ptr<part::ChunkIndex> index = part::estimateStats(config);
         if (!index->empty()) {
             fs::path d(config.get<std::string>("out.dir"));
             fs::path f = config.get<std::string>("part.prefix") + "_index.bin";