Revert "moves cli"

This reverts commit 71f1093.

Author: skyler-ruiter

examples/caller_allocated_output.cpp

@@ -134,40 +134,6 @@ class Pipeline {
         cudaStream_t stream = 0
     );
 
-    /**
-     * Compress into a caller-allocated device buffer.
-     *
-     * @param d_input          Device pointer to raw input.
-     * @param input_size       Input size in bytes.
-     * @param d_output         Caller-allocated device buffer for compressed bytes.
-     * @param output_capacity  Capacity of d_output in bytes.
-     * @param output_size      Receives the compressed size in bytes.
-     * @param stream           CUDA stream for all GPU operations.
-     */
-    void compressInto(
-        const void* d_input,
-        size_t      input_size,
-        void*       d_output,
-        size_t      output_capacity,
-        size_t*     output_size,
-        cudaStream_t stream = 0
-    );
-
-    /**
-     * Compress multi-source input into a caller-allocated device buffer.
-     *
-     * Output format matches compress(const std::vector<InputSpec>&):
-     * single output buffer for single-source pipelines; concat format for
-     * multi-source pipelines.
-     */
-    void compressInto(
-        const std::vector<InputSpec>& inputs,
-        void*       d_output,
-        size_t      output_capacity,
-        size_t*     output_size,
-        cudaStream_t stream = 0
-    );
-
     /**
      * Compress (multi-source). One InputSpec per source stage; order does not matter.
      * *d_output is pool-owned — do NOT cudaFree.
@@ -211,45 +177,6 @@ class Pipeline {
         cudaStream_t stream = 0
     );
 
-    /**
-     * Decompress into a caller-allocated device buffer (single-source only).
-     *
-     * @param d_input          nullptr to read from live forward DAG buffers, or
-     *                         a device pointer to external compressed bytes.
-     * @param input_size       Byte size of d_input (ignored when d_input is nullptr).
-     * @param d_output         Caller-allocated device buffer for decompressed bytes.
-     * @param output_capacity  Capacity of d_output in bytes.
-     * @param output_size      Receives the exact decompressed size in bytes.
-     * @param stream           CUDA stream for all GPU operations.
-     */
-    void decompressInto(
-        const void* d_input,
-        size_t      input_size,
-        void*       d_output,
-        size_t      output_capacity,
-        size_t*     output_size,
-        cudaStream_t stream = 0
-    );
-
-    /**
-     * Decompress multi-source data into caller-allocated output buffers.
-     *
-     * @param d_input             nullptr to read from live forward DAG buffers,
-     *                            or a device pointer to external compressed bytes.
-     * @param input_size          Byte size of d_input (ignored when d_input is nullptr).
-     * @param d_outputs           One device pointer per source output.
-     * @param output_capacities   Capacity (bytes) for each output pointer.
-     * @param stream              CUDA stream for all GPU operations.
-     * @return Exact decompressed size (bytes) for each source output.
-     */
-    std::vector<size_t> decompressMultiInto(
-        const void*                 d_input,
-        size_t                      input_size,
-        const std::vector<void*>&   d_outputs,
-        const std::vector<size_t>&  output_capacities,
-        cudaStream_t                stream = 0
-    );
-
     /**
      * Decompress (multi-source). Returns one {device_ptr, size} pair per source,
      * in the same order as forward source discovery. Ownership follows
@@ -261,32 +188,6 @@ class Pipeline {
         cudaStream_t stream    = 0
     );
 
-    /**
-     * Maximum compressed output size for the current finalized pipeline.
-     *
-     * Returned value is an upper bound suitable for caller allocation before
-     * compressInto(...). For multi-source pipelines this corresponds to the
-     * single concat output format returned by compress().
-     */
-    size_t getMaxCompressedOutputSize() const;
-
-    /**
-     * Maximum decompressed output size (single-source pipelines only).
-     *
-     * Value is derived from the most recent compress() input size when available,
-     * otherwise from finalize-time size hints. Returns an upper bound suitable
-     * for caller allocation before decompressInto().
-     */
-    size_t getMaxDecompressedOutputSize() const;
-
-    /**
-     * Maximum decompressed output size per source (multi-source aware).
-     *
-     * Order matches decompressMulti()/decompressMultiInto() source order.
-     * Values are upper bounds suitable for caller allocation.
-     */
-    std::vector<size_t> getMaxDecompressedOutputSizes() const;
-
     /** Free non-persistent buffers and reset execution state for re-use. */
     void reset(cudaStream_t stream = 0);
 
@@ -369,12 +270,6 @@ class Pipeline {
     /** Parse the FZM header from a file without decompressing the payload. */
     static FZMFileHeader readHeader(const std::string& filename);
 
-    /** Exact decompressed output size from an FZM file (single-source convenience). */
-    static size_t getDecompressedOutputSizeFromFile(const std::string& filename);
-
-    /** Exact decompressed output sizes (one per source) from an FZM file header. */
-    static std::vector<size_t> getDecompressedOutputSizesFromFile(const std::string& filename);
-
     /** Build the FZM header from current pipeline state. Requires a prior compress(). */
     FZMFileHeader buildHeader() const;
 
@@ -437,14 +332,6 @@ class Pipeline {
     std::vector<Stage*> getSourceStages() const;
     std::vector<Stage*> getSinkStages() const;
 
-    std::vector<std::pair<void*, size_t>> decompressMultiImpl(
-        const void*                 d_input,
-        size_t                      input_size,
-        cudaStream_t                stream,
-        const std::vector<void*>*   caller_outputs,
-        const std::vector<size_t>*  caller_capacities
-    );
-
     // ── Inverse DAG helpers ───────────────────────────────────────────────────
 
     /** Compact description of one forward stage used by buildInverseDAG(). */

include/pipeline/compressor.h

@@ -584,95 +584,6 @@ size_t Pipeline::getPoolThreshold() const {
     return mem_pool_ ? mem_pool_->getConfiguredSize() : 0;
 }
 
-size_t Pipeline::getMaxCompressedOutputSize() const {
-    if (!is_finalized_) {
-        throw std::runtime_error(
-            "getMaxCompressedOutputSize() requires finalize() to be called first");
-    }
-    if (!dag_) {
-        throw std::runtime_error("getMaxCompressedOutputSize(): DAG is not initialized");
-    }
-    if (output_buffer_ids_.empty()) {
-        throw std::runtime_error(
-            "getMaxCompressedOutputSize(): pipeline has no detected output buffers");
-    }
-
-    if (!needs_concat_) {
-        return dag_->getBufferSize(output_buffer_ids_[0]);
-    }
-
-    // Mirror concat format capacity computation using buffer capacities rather
-    // than run-time actual sizes.
-    auto align16_local = [](size_t x) -> size_t { return (x + 15u) & ~15u; };
-
-    const size_t n = output_buffer_ids_.size();
-    size_t total = align16_local(sizeof(uint32_t) + n * sizeof(uint64_t));
-    for (int buf_id : output_buffer_ids_) {
-        total += align16_local(dag_->getBufferSize(buf_id));
-    }
-    return total;
-}
-
-std::vector<size_t> Pipeline::getMaxDecompressedOutputSizes() const {
-    if (!is_finalized_) {
-        throw std::runtime_error(
-            "getMaxDecompressedOutputSizes() requires finalize() to be called first");
-    }
-
-    std::vector<size_t> out;
-    out.reserve(input_nodes_.size());
-
-    for (size_t i = 0; i < input_nodes_.size(); ++i) {
-        size_t max_size = 0;
-
-        // Most accurate value: actual source size from the most recent compress().
-        if (i < source_input_sizes_.size() && source_input_sizes_[i] > 0) {
-            max_size = source_input_sizes_[i];
-        }
-
-        // Fallback: per-source finalize-time hint.
-        if (max_size == 0) {
-            Stage* src_stage = input_nodes_[i]->stage;
-            auto hint_it = per_source_hints_.find(src_stage);
-            if (hint_it != per_source_hints_.end() && hint_it->second > 0) {
-                max_size = hint_it->second;
-            }
-        }
-
-        // Fallback: constructor hint (single-source common case).
-        if (max_size == 0 && input_size_hint_ > 0) {
-            max_size = input_size_hint_;
-        }
-
-        // Final fallback: finalized DAG input buffer size if it is not the
-        // placeholder 1-byte value used when no hint is available.
-        if (max_size == 0 && i < input_buffer_ids_.size() && dag_) {
-            const size_t dag_size = dag_->getBufferSize(input_buffer_ids_[i]);
-            if (dag_size > 1) max_size = dag_size;
-        }
-
-        // Returned value is a max allocation size; preserve alignment rounding.
-        if (max_size > 0 && input_alignment_bytes_ > 1) {
-            max_size = ((max_size + input_alignment_bytes_ - 1) / input_alignment_bytes_)
-                     * input_alignment_bytes_;
-        }
-
-        out.push_back(max_size);
-    }
-
-    return out;
-}
-
-size_t Pipeline::getMaxDecompressedOutputSize() const {
-    auto sizes = getMaxDecompressedOutputSizes();
-    if (sizes.size() != 1) {
-        throw std::runtime_error(
-            "getMaxDecompressedOutputSize() is single-source only; use getMaxDecompressedOutputSizes() for " +
-            std::to_string(sizes.size()) + " source outputs");
-    }
-    return sizes[0];
-}
-
 size_t Pipeline::getCurrentMemoryUsage() const {
     return dag_ ? dag_->getCurrentMemoryUsage() : 0;
 }