Incorporating skycleaver functionality to skyweaver

cmake/compiler_settings.cmake

@@ -5,8 +5,10 @@ if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "RELEASE")
 endif ()
 
+#set(CMAKE_VERBOSE_MAKEFILE 1)
+
 # Set compiler flags
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -fopenmp")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -fopenmp -std=gnu++20")
 
 set(ARCH "broadwell" CACHE STRING "target architecture (-march=native, x86-64), defautls to broadwell")
 

cpp/skyweaver/CMakeLists.txt

@@ -18,6 +18,9 @@ set(skyweaver_src
    src/Timer.cpp
    src/Transposer.cu
    src/WeightsManager.cu
+   src/SkyCleaver.cu
+   src/SigprocHeader.cpp
+
    )
 
 set(skyweaver_inc
@@ -38,6 +41,8 @@ set(skyweaver_inc
     Timer.hpp
     Transposer.cuh
     WeightsManager.cuh
+    MultiFileWriter.cuh
+    SigprocHeader.hpp
    )
 
 set(SKYWEAVER_LIBRARIES ${CMAKE_PROJECT_NAME} ${DEPENDENCY_LIBRARIES})
@@ -106,6 +111,13 @@ target_link_libraries(skyweavercpp
     OpenMP::OpenMP_CXX)
 install(TARGETS skyweavercpp DESTINATION bin)
 
+cuda_add_executable(skycleaver src/skycleaver_cli.cu)
+target_link_libraries(skycleaver 
+    ${SKYWEAVER_LIBRARIES} 
+    ${DEPENDENCY_LIBRARIES} 
+    OpenMP::OpenMP_CXX)
+install(TARGETS skycleaver DESTINATION bin)
+
 #install (TARGETS ... DESTINATION bin)
 #install (TARGETS ${CMAKE_PROJECT_NAME}
 #         RUNTIME DESTINATION bin

cpp/skyweaver/DescribedVector.hpp

@@ -127,6 +127,23 @@ struct DescribedVector {
         _vector.resize(calculate_nelements());
     }
 
+    /**
+     * @brief Construct a new Described Vector object of specific size
+     *
+     * @param sizes The sizes of the dimensions (must match the number of
+     * dimensions)
+     */
+    DescribedVector(std::initializer_list<std::size_t> sizes, value_type default_value)
+        : _dms_stale(true), _frequencies_stale(true), _sizes(sizes),
+          _dims{dims...}, _tsamp(0.0)
+    {
+        if(_sizes.size() != sizeof...(dims)) {
+            throw std::invalid_argument(
+                "Number of sizes must match number of dimensions");
+        }
+        _vector.resize(calculate_nelements(), default_value);
+    }
+
     /**
      * @brief Destroy the Described Vector object
      *
@@ -213,6 +230,12 @@ struct DescribedVector {
      */
     auto const& operator[](std::size_t idx) const { return _vector[idx]; }
 
+
+    // also the at() method
+    auto& at(std::size_t idx) { return _vector[idx]; }
+    auto const& at(std::size_t idx) const { return _vector[idx]; }
+
+
     /**
      * @brief Resize the dimensions of the vector
      *
@@ -648,7 +671,7 @@ using BTFPowersH = DescribedVector<thrust::host_vector<T, PinnedAllocator<T>>,
 template <typename T>
 using BTFPowersD =
     DescribedVector<thrust::device_vector<T>, BeamDim, TimeDim, FreqDim>;
-// Incoherent dedisperser outputs
+// Incoherent dedisperser outputs, also used for skycleaver
 template <typename T>
 using TDBPowersH = DescribedVector<thrust::host_vector<T, PinnedAllocator<T>>,
                                    TimeDim,
@@ -667,6 +690,13 @@ template <typename T>
 using FPAStatsD =
     DescribedVector<thrust::device_vector<T>, FreqDim, PolnDim, AntennaDim>;
 
+//skycleaver output vectors
+
+template <typename T>
+using TFPowersH = DescribedVector<thrust::host_vector<T, PinnedAllocator<T>>,
+                                  TimeDim,
+                                  FreqDim>;
+
 } // namespace skyweaver
 
 #endif // SKYWEAVER_DESCRIBEDVECTORS_HPP

cpp/skyweaver/Header.hpp

@@ -37,6 +37,26 @@ class Header
     template <typename T>
     T get(char const* key) const;
 
+
+    /**
+      * @brief      Get a value from the header or return a default value
+      *
+      * @param      key            An ASCII key (the name of the value to get)
+      * @param[in]  default_value  The default value to return if the key is not found
+      *
+      * @tparam     T              The data type of the parameter to be read
+      *
+      * @return     The value corresponding to the given key or the default value
+     */
+    template <typename T>
+    T get_or_default(char const* key, T default_value) const{
+        if(has_key(key)){
+            return get<T>(key);
+        }
+        BOOST_LOG_TRIVIAL(warning) << "Header did not have key: " << key << ". Returning default value: " << default_value;
+        return default_value;
+    }
+
     /**
      * @brief      Set a value in the header
      *
@@ -72,6 +92,7 @@ class Header
 
   private:
     void fetch_header_string(char const* key) const;
+    bool has_key(char const* key) const;
 
   private:
     psrdada_cpp::RawBytes& _header;

cpp/skyweaver/MultiFileReader.cuh

@@ -36,6 +36,7 @@ class skyweaver::MultiFileReader
     std::size_t _dada_header_size;
     std::size_t _total_size;
     bool _is_open;
+
 
     void read_header(std::vector<char>& headerBytes);
     void check_contiguity();
@@ -49,14 +50,18 @@ class skyweaver::MultiFileReader
     void open_previous();
     void close();
     void seekg(long pos, std::ios_base::seekdir dir = std::ios_base::beg);
+
     std::size_t tellg() const;
     bool eof() const;
     bool good() const;
     bool can_read(std::size_t bytes) const;
     std::streamsize read(char* raw_ptr, std::streamsize bytes);
+
+
     bool is_open() const;
     std::size_t
     safe_read(std::ifstream& input_stream, char* buffer, std::size_t nbytes);
+    std::vector<std::string> const& get_dada_files() const;
 
     std::size_t get_total_size() const;
 

cpp/skyweaver/MultiFileWriter.cuh

@@ -12,13 +12,75 @@
 
 namespace skyweaver
 {
+
+struct MultiFileWriterConfig {
+    std::size_t header_size;
+    std::size_t max_file_size;
+    std::string stokes_mode;
+    std::string output_dir;
+    std::string base_output_dir;
+    std::string prefix;
+    std::string extension;
+    std::string output_basename;
+
+    MultiFileWriterConfig()
+        : header_size(4096), max_file_size(2147483647), stokes_mode("I"),
+          output_dir("default/"), prefix(""), extension("") {};
+
+    MultiFileWriterConfig(std::size_t header_size,
+                          std::size_t max_file_size,
+                          std::string stokes_mode,
+                          std::string output_dir,
+                          std::string prefix,
+                          std::string extension)
+        : header_size(header_size), max_file_size(max_file_size),
+          stokes_mode(stokes_mode), output_dir(output_dir), prefix(prefix),
+          extension(extension), output_basename("") {};
+
+    MultiFileWriterConfig(MultiFileWriterConfig const& other)
+        : header_size(other.header_size), max_file_size(other.max_file_size),
+          stokes_mode(other.stokes_mode), output_dir(other.output_dir),
+          base_output_dir(other.base_output_dir), prefix(other.prefix),
+          extension(other.extension), output_basename(other.output_basename) {};
+
+    MultiFileWriterConfig& operator=(MultiFileWriterConfig const& other)
+    {
+        header_size     = other.header_size;
+        max_file_size   = other.max_file_size;
+        stokes_mode     = other.stokes_mode;
+        output_dir      = other.output_dir;
+        prefix          = other.prefix;
+        extension       = other.extension;
+        output_basename = other.output_basename;
+        base_output_dir = other.base_output_dir;
+        return *this;
+    }
+
+    std::string to_string()
+    {
+        return "header_size: " + std::to_string(header_size) +
+               ", max_file_size: " + std::to_string(max_file_size) +
+               ", stokes_mode: " + stokes_mode + ", output_dir: " + output_dir +
+               ", prefix: " + prefix + ", extension: " + extension +
+               ", output_basename: " + output_basename +
+               ", base_output_dir: " + base_output_dir;
+    }
+};
 /**
  * @brief A class for handling writing of DescribedVectors
  *
  */
 template <typename VectorType>
 class MultiFileWriter
 {
+  public:
+    using CreateStreamCallBackType =
+        std::function<std::unique_ptr<FileOutputStream>(
+            MultiFileWriterConfig const&,
+            ObservationHeader const&,
+            VectorType const&,
+            std::size_t)>;
+
   public:
     /**
      * @brief Construct a new Multi File Writer object
@@ -27,7 +89,13 @@ class MultiFileWriter
      * @param tag     A string tag to be added to the file name
      *                (used to avoid clashing file names).
      */
-    MultiFileWriter(PipelineConfig const& config, std::string tag = "");
+    // MultiFileWriter(PipelineConfig const& config, std::string tag = "");
+    MultiFileWriter(PipelineConfig const& config,
+                    std::string tag,
+                    CreateStreamCallBackType create_stream_callback);
+    MultiFileWriter(MultiFileWriterConfig config,
+                    std::string tag,
+                    CreateStreamCallBackType create_stream_callback);
     MultiFileWriter(MultiFileWriter const&) = delete;
 
     /**
@@ -62,17 +130,19 @@ class MultiFileWriter
      */
     bool operator()(VectorType const& stream_data, std::size_t stream_idx = 0);
 
+    bool write(VectorType const& stream_data, std::size_t stream_idx = 0);
+
   private:
     bool has_stream(std::size_t stream_idx);
     FileOutputStream& create_stream(VectorType const& stream_data,
-                              std::size_t stream_idx);
+                                    std::size_t stream_idx);
     std::string get_output_dir(VectorType const& stream_data,
                                std::size_t stream_idx);
     std::string get_basefilename(VectorType const& stream_data,
                                  std::size_t stream_idx);
     std::string get_extension(VectorType const& stream_data);
-
-    PipelineConfig const& _config;
+    CreateStreamCallBackType _create_stream_callback;
+    MultiFileWriterConfig _config;
     std::string _tag;
     ObservationHeader _header;
     std::map<std::size_t, std::unique_ptr<FileOutputStream>> _file_streams;
@@ -83,5 +153,6 @@ class MultiFileWriter
 } // namespace skyweaver
 
 #include "skyweaver/detail/MultiFileWriter.cu"
+#include "skyweaver/detail/file_writer_callbacks.cpp"
 
 #endif // SKYWEAVER_MULTIFILEWRITER_CUH