FZGPUModules 2.0
GPU-accelerated modular compression pipelines
Loading...
Searching...
No Matches
stage_factory.h
Go to the documentation of this file.
1#pragma once
2
8#include "stage/stage.h"
9#include "fzm_format.h"
10#include "predictors/diff/diff.h"
11#include "coders/rle/rle.h"
12#include "fused/lorenzo_quant/lorenzo_quant.h"
13#include "predictors/lorenzo/lorenzo_stage.h"
14#include "transforms/zigzag/zigzag_stage.h"
15#include "transforms/negabinary/negabinary_stage.h"
16#include "shufflers/bitshuffle/bitshuffle_stage.h"
17#include "coders/rze/rze_stage.h"
18#include "coders/bitpack/bitpack_stage.h"
19#include "coders/huffman/huffman_stage.h"
20#include "coders/ans/ans_stage.h"
21#include "transforms/adm/adm_stage.h"
22
23#include <memory>
24#include <stdexcept>
25#include <cstring>
26
27namespace fz {
28
38inline Stage* createStage(StageType type, const uint8_t* config, size_t config_size) {
39 Stage* stage = nullptr;
40
41 switch (type) {
42 case StageType::LORENZO_QUANT: {
43 // Dims are restored by deserializeHeader(); template types come from stored fields.
44 if (config_size >= sizeof(LorenzoQuantConfig)) {
45 LorenzoQuantConfig lc;
46 std::memcpy(&lc, config, sizeof(LorenzoQuantConfig));
47 if (lc.input_type == DataType::FLOAT32 && lc.code_type == DataType::UINT16) {
48 auto* s = new LorenzoQuantStage<float, uint16_t>();
49 s->deserializeHeader(config, config_size);
50 stage = s;
51 } else if (lc.input_type == DataType::FLOAT64 && lc.code_type == DataType::UINT16) {
52 auto* s = new LorenzoQuantStage<double, uint16_t>();
53 s->deserializeHeader(config, config_size);
54 stage = s;
55 } else {
56 throw std::runtime_error(
57 "Unsupported Lorenzo template instantiation: input_type="
58 + std::to_string(static_cast<int>(lc.input_type))
59 + " code_type=" + std::to_string(static_cast<int>(lc.code_type)));
60 }
61 } else {
62 throw std::runtime_error("Lorenzo config too small: " + std::to_string(config_size));
63 }
64 break;
65 }
66
67 case StageType::DIFFERENCE: {
68 // Header: [0] TIn DataType, [1] TOut DataType, [2..5] chunk_size.
69 // TIn == TOut → same-type (legacy); TIn signed + TOut unsigned → negabinary-fused.
70 if (config_size >= 2) {
71 DataType tin_dt = static_cast<DataType>(config[0]);
72 DataType tout_dt = static_cast<DataType>(config[1]);
73 // Negabinary-fused instantiations
74 if (tin_dt == DataType::INT8 && tout_dt == DataType::UINT8)
75 stage = new DifferenceStage<int8_t, uint8_t>();
76 else if (tin_dt == DataType::INT16 && tout_dt == DataType::UINT16)
77 stage = new DifferenceStage<int16_t, uint16_t>();
78 else if (tin_dt == DataType::INT32 && tout_dt == DataType::UINT32)
79 stage = new DifferenceStage<int32_t, uint32_t>();
80 else if (tin_dt == DataType::INT64 && tout_dt == DataType::UINT64)
81 stage = new DifferenceStage<int64_t, uint64_t>();
82 // Same-type instantiations
83 else if (tin_dt == DataType::FLOAT32) stage = new DifferenceStage<float>();
84 else if (tin_dt == DataType::FLOAT64) stage = new DifferenceStage<double>();
85 else if (tin_dt == DataType::UINT8) stage = new DifferenceStage<uint8_t>();
86 else if (tin_dt == DataType::UINT16) stage = new DifferenceStage<uint16_t>();
87 else if (tin_dt == DataType::UINT32) stage = new DifferenceStage<uint32_t>();
88 else if (tin_dt == DataType::INT32) stage = new DifferenceStage<int32_t>();
89 else if (tin_dt == DataType::INT64) stage = new DifferenceStage<int64_t>();
90 else
91 throw std::runtime_error("Unsupported Difference data type: "
92 + std::to_string(static_cast<int>(tin_dt)));
93 stage->deserializeHeader(config, config_size);
94 } else if (config_size >= 1) {
95 // Legacy 1-byte header (same-type only)
96 DataType dt = static_cast<DataType>(config[0]);
97 switch (dt) {
98 case DataType::FLOAT32: stage = new DifferenceStage<float>(); break;
99 case DataType::FLOAT64: stage = new DifferenceStage<double>(); break;
100 case DataType::UINT8: stage = new DifferenceStage<uint8_t>(); break;
101 case DataType::UINT16: stage = new DifferenceStage<uint16_t>(); break;
102 case DataType::UINT32: stage = new DifferenceStage<uint32_t>(); break;
103 case DataType::INT32: stage = new DifferenceStage<int32_t>(); break;
104 case DataType::INT64: stage = new DifferenceStage<int64_t>(); break;
105 default:
106 throw std::runtime_error("Unsupported Difference data type: "
107 + std::to_string(static_cast<int>(dt)));
108 }
109 } else {
110 stage = new DifferenceStage<float>();
111 }
112 break;
113 }
114
115 case StageType::RLE: {
116 if (config_size >= 1) {
117 DataType dt;
118 std::memcpy(&dt, config, sizeof(DataType));
119 switch (dt) {
120 case DataType::UINT8: stage = new RLEStage<uint8_t>(); break;
121 case DataType::UINT16: stage = new RLEStage<uint16_t>(); break;
122 case DataType::UINT32: stage = new RLEStage<uint32_t>(); break;
123 case DataType::INT32: stage = new RLEStage<int32_t>(); break;
124 default:
125 throw std::runtime_error("Unsupported RLE data type: "
126 + std::to_string(static_cast<int>(dt)));
127 }
128 stage->deserializeHeader(config, config_size);
129 } else {
130 // No config — default to uint16_t
131 stage = new RLEStage<uint16_t>();
132 }
133 break;
134 }
135
136 case StageType::ZIGZAG: {
137 if (config_size >= 2) {
138 DataType tin_dt = static_cast<DataType>(config[0]);
139 DataType tout_dt = static_cast<DataType>(config[1]);
140 if (tin_dt == DataType::INT8 && tout_dt == DataType::UINT8)
141 stage = new ZigzagStage<int8_t, uint8_t>();
142 else if (tin_dt == DataType::INT16 && tout_dt == DataType::UINT16)
143 stage = new ZigzagStage<int16_t, uint16_t>();
144 else if (tin_dt == DataType::INT32 && tout_dt == DataType::UINT32)
145 stage = new ZigzagStage<int32_t, uint32_t>();
146 else if (tin_dt == DataType::INT64 && tout_dt == DataType::UINT64)
147 stage = new ZigzagStage<int64_t, uint64_t>();
148 else
149 throw std::runtime_error(
150 "Unsupported ZigzagStage type pair: TIn="
151 + std::to_string(static_cast<int>(tin_dt))
152 + " TOut=" + std::to_string(static_cast<int>(tout_dt)));
153 } else {
154 // Default: int32_t → uint32_t
155 stage = new ZigzagStage<int32_t, uint32_t>();
156 }
157 stage->deserializeHeader(config, config_size);
158 break;
159 }
160
161 case StageType::NEGABINARY: {
162 if (config_size >= 2) {
163 DataType tin_dt = static_cast<DataType>(config[0]);
164 DataType tout_dt = static_cast<DataType>(config[1]);
165 if (tin_dt == DataType::INT8 && tout_dt == DataType::UINT8)
166 stage = new NegabinaryStage<int8_t, uint8_t>();
167 else if (tin_dt == DataType::INT16 && tout_dt == DataType::UINT16)
168 stage = new NegabinaryStage<int16_t, uint16_t>();
169 else if (tin_dt == DataType::INT32 && tout_dt == DataType::UINT32)
170 stage = new NegabinaryStage<int32_t, uint32_t>();
171 else if (tin_dt == DataType::INT64 && tout_dt == DataType::UINT64)
172 stage = new NegabinaryStage<int64_t, uint64_t>();
173 else
174 throw std::runtime_error(
175 "Unsupported NegabinaryStage type pair: TIn="
176 + std::to_string(static_cast<int>(tin_dt))
177 + " TOut=" + std::to_string(static_cast<int>(tout_dt)));
178 } else {
179 stage = new NegabinaryStage<int32_t, uint32_t>();
180 }
181 stage->deserializeHeader(config, config_size);
182 break;
183 }
184
185 case StageType::BITSHUFFLE: {
186 auto* s = new BitshuffleStage();
187 s->deserializeHeader(config, config_size);
188 stage = s;
189 break;
190 }
191
192 case StageType::BITPACK: {
193 // config[0] holds the DataType of T; use it to pick the instantiation.
194 DataType dt = (config_size > 0)
195 ? static_cast<DataType>(config[0])
196 : DataType::UINT16;
197 if (dt == DataType::UINT8) stage = new BitpackStage<uint8_t>();
198 else if (dt == DataType::UINT16) stage = new BitpackStage<uint16_t>();
199 else if (dt == DataType::UINT32) stage = new BitpackStage<uint32_t>();
200 else throw std::runtime_error(
201 "Unsupported BitpackStage DataType: "
202 + std::to_string(static_cast<int>(dt)));
203 stage->deserializeHeader(config, config_size);
204 break;
205 }
206
207 case StageType::RZE: {
208 auto* s = new RZEStage();
209 s->deserializeHeader(config, config_size);
210 stage = s;
211 break;
212 }
213
214 case StageType::HUFFMAN: {
215 // config[0] holds the DataType of T; use it to pick the instantiation.
216 DataType dt = (config_size > 0)
217 ? static_cast<DataType>(config[0])
218 : DataType::UINT16;
219 if (dt == DataType::UINT8) stage = new HuffmanStage<uint8_t>();
220 else if (dt == DataType::UINT16) stage = new HuffmanStage<uint16_t>();
221 else if (dt == DataType::UINT32) stage = new HuffmanStage<uint32_t>();
222 else throw std::runtime_error(
223 "Unsupported HuffmanStage DataType: "
224 + std::to_string(static_cast<int>(dt)));
225 stage->deserializeHeader(config, config_size);
226 break;
227 }
228
229 case StageType::LORENZO: {
230 DataType dt = (config_size >= sizeof(LorenzoConfig))
231 ? static_cast<DataType>(config[0])
232 : DataType::INT32;
233 if (dt == DataType::INT8) stage = new LorenzoStage<int8_t>();
234 else if (dt == DataType::INT16) stage = new LorenzoStage<int16_t>();
235 else if (dt == DataType::INT32) stage = new LorenzoStage<int32_t>();
236 else if (dt == DataType::INT64) stage = new LorenzoStage<int64_t>();
237 else throw std::runtime_error(
238 "Unsupported LorenzoStage DataType: "
239 + std::to_string(static_cast<int>(dt)));
240 stage->deserializeHeader(config, config_size);
241 break;
242 }
243
244 case StageType::ANS: {
245 auto* s = new ANSStage();
246 s->deserializeHeader(config, config_size);
247 stage = s;
248 break;
249 }
250
251 case StageType::ADM: {
252 auto* s = new ADMStage();
253 s->deserializeHeader(config, config_size);
254 stage = s;
255 break;
256 }
257
258 default:
259 throw std::runtime_error("Unknown stage type: "
260 + std::to_string(static_cast<uint16_t>(type)));
261 }
262
263 return stage;
264}
265
266} // namespace fz
adm_stage.h
Adaptive Data Mapping (ADM) stage — remaps u16/u32 integer streams into a compact 8-bit symbol domain...
ans_stage.h
rANS entropy coding stage (GPU, via vendored dietGPU kernel templates).
bitpack_stage.h
Bit-packing stage: packs N-bit integers into a dense byte stream.
bitshuffle_stage.h
GPU bit-matrix transpose stage (W × N bit shuffle over fixed-size chunks).
fz::BitpackStage
Definition bitpack_stage.h:47
fz::BitshuffleStage
Definition bitshuffle_stage.h:43
fz::DifferenceStage
Definition diff.h:51
fz::HuffmanStage
Definition huffman_stage.h:68
fz::LorenzoQuantStage
Definition lorenzo_quant.h:90
fz::LorenzoStage
Definition lorenzo_stage.h:51
fz::NegabinaryStage
Definition negabinary_stage.h:34
fz::RLEStage
Definition rle.h:31
fz::RZEStage
Definition rze_stage.h:51
fz::Stage
Definition stage.h:30
fz::Stage::deserializeHeader
virtual void deserializeHeader(const uint8_t *header_buffer, size_t size)
Definition stage.h:149
fz::ZigzagStage
Definition zigzag_stage.h:30
diff.h
First-order difference coding stage with optional negabinary fusion.
fzm_format.h
FZM binary file format definitions — structs, enums, and helpers.
huffman_stage.h
Huffman entropy coding stage with selectable encode mode.
lorenzo_quant.h
Fused Lorenzo predictor and quantizer stage.
lorenzo_stage.h
Plain integer Lorenzo predictor (delta coding / prefix sum). Lossless.
fz
Definition fzm_format.h:25
fz::createStage
Stage * createStage(StageType type, const uint8_t *config, size_t config_size)
Definition stage_factory.h:38
fz::StageType
StageType
Stage type identifiers written into the FZM header.
Definition fzm_format.h:76
fz::StageType::ANS
@ ANS
rANS entropy coder (GPU, via dietGPU)
fz::StageType::ADM
@ ADM
Adaptive Data Mapping transform (MANS)
fz::DataType
DataType
Element data type identifiers used in buffer and stage descriptors.
Definition fzm_format.h:104
negabinary_stage.h
Element-wise negabinary encode/decode stage (TIn[] ↔ TOut[]).
rle.h
Run-Length Encoding stage (lossless, stream-ordered).
rze_stage.h
Recursive Zero-byte Elimination stage — lossless byte-stream compressor.
stage.h
Base class interface for all compression stages.
fz::LorenzoConfig
Definition lorenzo_stage.h:27
fz::LorenzoQuantConfig
Definition lorenzo_quant.h:43
fz::LorenzoQuantConfig::input_type
DataType input_type
Original input type (1B).
Definition lorenzo_quant.h:48
fz::LorenzoQuantConfig::code_type
DataType code_type
Quantization code type (1B).
Definition lorenzo_quant.h:49
zigzag_stage.h
Element-wise zigzag encode/decode stage (TIn[] ↔ TOut[]).