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
20#include <memory>
21#include <stdexcept>
22#include <cstring>
23
24namespace fz {
25
35inline Stage* createStage(StageType type, const uint8_t* config, size_t config_size) {
36 Stage* stage = nullptr;
37
38 switch (type) {
39 case StageType::LORENZO_QUANT: {
40 // Dims are restored by deserializeHeader(); template types come from stored fields.
41 if (config_size >= sizeof(LorenzoQuantConfig)) {
42 LorenzoQuantConfig lc;
43 std::memcpy(&lc, config, sizeof(LorenzoQuantConfig));
44 if (lc.input_type == DataType::FLOAT32 && lc.code_type == DataType::UINT16) {
45 auto* s = new LorenzoQuantStage<float, uint16_t>();
46 s->deserializeHeader(config, config_size);
47 stage = s;
48 } else if (lc.input_type == DataType::FLOAT64 && lc.code_type == DataType::UINT16) {
49 auto* s = new LorenzoQuantStage<double, uint16_t>();
50 s->deserializeHeader(config, config_size);
51 stage = s;
52 } else {
53 throw std::runtime_error(
54 "Unsupported Lorenzo template instantiation: input_type="
55 + std::to_string(static_cast<int>(lc.input_type))
56 + " code_type=" + std::to_string(static_cast<int>(lc.code_type)));
57 }
58 } else {
59 throw std::runtime_error("Lorenzo config too small: " + std::to_string(config_size));
60 }
61 break;
62 }
63
64 case StageType::DIFFERENCE: {
65 // Header: [0] TIn DataType, [1] TOut DataType, [2..5] chunk_size.
66 // TIn == TOut → same-type (legacy); TIn signed + TOut unsigned → negabinary-fused.
67 if (config_size >= 2) {
68 DataType tin_dt = static_cast<DataType>(config[0]);
69 DataType tout_dt = static_cast<DataType>(config[1]);
70 // Negabinary-fused instantiations
71 if (tin_dt == DataType::INT8 && tout_dt == DataType::UINT8)
72 stage = new DifferenceStage<int8_t, uint8_t>();
73 else if (tin_dt == DataType::INT16 && tout_dt == DataType::UINT16)
74 stage = new DifferenceStage<int16_t, uint16_t>();
75 else if (tin_dt == DataType::INT32 && tout_dt == DataType::UINT32)
76 stage = new DifferenceStage<int32_t, uint32_t>();
77 else if (tin_dt == DataType::INT64 && tout_dt == DataType::UINT64)
78 stage = new DifferenceStage<int64_t, uint64_t>();
79 // Same-type instantiations
80 else if (tin_dt == DataType::FLOAT32) stage = new DifferenceStage<float>();
81 else if (tin_dt == DataType::FLOAT64) stage = new DifferenceStage<double>();
82 else if (tin_dt == DataType::UINT8) stage = new DifferenceStage<uint8_t>();
83 else if (tin_dt == DataType::UINT16) stage = new DifferenceStage<uint16_t>();
84 else if (tin_dt == DataType::UINT32) stage = new DifferenceStage<uint32_t>();
85 else if (tin_dt == DataType::INT32) stage = new DifferenceStage<int32_t>();
86 else if (tin_dt == DataType::INT64) stage = new DifferenceStage<int64_t>();
87 else
88 throw std::runtime_error("Unsupported Difference data type: "
89 + std::to_string(static_cast<int>(tin_dt)));
90 stage->deserializeHeader(config, config_size);
91 } else if (config_size >= 1) {
92 // Legacy 1-byte header (same-type only)
93 DataType dt = static_cast<DataType>(config[0]);
94 switch (dt) {
95 case DataType::FLOAT32: stage = new DifferenceStage<float>(); break;
96 case DataType::FLOAT64: stage = new DifferenceStage<double>(); break;
97 case DataType::UINT8: stage = new DifferenceStage<uint8_t>(); break;
98 case DataType::UINT16: stage = new DifferenceStage<uint16_t>(); break;
99 case DataType::UINT32: stage = new DifferenceStage<uint32_t>(); break;
100 case DataType::INT32: stage = new DifferenceStage<int32_t>(); break;
101 case DataType::INT64: stage = new DifferenceStage<int64_t>(); break;
102 default:
103 throw std::runtime_error("Unsupported Difference data type: "
104 + std::to_string(static_cast<int>(dt)));
105 }
106 } else {
107 stage = new DifferenceStage<float>();
108 }
109 break;
110 }
111
112 case StageType::RLE: {
113 if (config_size >= 1) {
114 DataType dt;
115 std::memcpy(&dt, config, sizeof(DataType));
116 switch (dt) {
117 case DataType::UINT8: stage = new RLEStage<uint8_t>(); break;
118 case DataType::UINT16: stage = new RLEStage<uint16_t>(); break;
119 case DataType::UINT32: stage = new RLEStage<uint32_t>(); break;
120 case DataType::INT32: stage = new RLEStage<int32_t>(); break;
121 default:
122 throw std::runtime_error("Unsupported RLE data type: "
123 + std::to_string(static_cast<int>(dt)));
124 }
125 stage->deserializeHeader(config, config_size);
126 } else {
127 // No config — default to uint16_t
128 stage = new RLEStage<uint16_t>();
129 }
130 break;
131 }
132
133 case StageType::ZIGZAG: {
134 if (config_size >= 2) {
135 DataType tin_dt = static_cast<DataType>(config[0]);
136 DataType tout_dt = static_cast<DataType>(config[1]);
137 if (tin_dt == DataType::INT8 && tout_dt == DataType::UINT8)
138 stage = new ZigzagStage<int8_t, uint8_t>();
139 else if (tin_dt == DataType::INT16 && tout_dt == DataType::UINT16)
140 stage = new ZigzagStage<int16_t, uint16_t>();
141 else if (tin_dt == DataType::INT32 && tout_dt == DataType::UINT32)
142 stage = new ZigzagStage<int32_t, uint32_t>();
143 else if (tin_dt == DataType::INT64 && tout_dt == DataType::UINT64)
144 stage = new ZigzagStage<int64_t, uint64_t>();
145 else
146 throw std::runtime_error(
147 "Unsupported ZigzagStage type pair: TIn="
148 + std::to_string(static_cast<int>(tin_dt))
149 + " TOut=" + std::to_string(static_cast<int>(tout_dt)));
150 } else {
151 // Default: int32_t → uint32_t
152 stage = new ZigzagStage<int32_t, uint32_t>();
153 }
154 stage->deserializeHeader(config, config_size);
155 break;
156 }
157
158 case StageType::NEGABINARY: {
159 if (config_size >= 2) {
160 DataType tin_dt = static_cast<DataType>(config[0]);
161 DataType tout_dt = static_cast<DataType>(config[1]);
162 if (tin_dt == DataType::INT8 && tout_dt == DataType::UINT8)
163 stage = new NegabinaryStage<int8_t, uint8_t>();
164 else if (tin_dt == DataType::INT16 && tout_dt == DataType::UINT16)
165 stage = new NegabinaryStage<int16_t, uint16_t>();
166 else if (tin_dt == DataType::INT32 && tout_dt == DataType::UINT32)
167 stage = new NegabinaryStage<int32_t, uint32_t>();
168 else if (tin_dt == DataType::INT64 && tout_dt == DataType::UINT64)
169 stage = new NegabinaryStage<int64_t, uint64_t>();
170 else
171 throw std::runtime_error(
172 "Unsupported NegabinaryStage type pair: TIn="
173 + std::to_string(static_cast<int>(tin_dt))
174 + " TOut=" + std::to_string(static_cast<int>(tout_dt)));
175 } else {
176 stage = new NegabinaryStage<int32_t, uint32_t>();
177 }
178 stage->deserializeHeader(config, config_size);
179 break;
180 }
181
182 case StageType::BITSHUFFLE: {
183 auto* s = new BitshuffleStage();
184 s->deserializeHeader(config, config_size);
185 stage = s;
186 break;
187 }
188
189 case StageType::BITPACK: {
190 // config[0] holds the DataType of T; use it to pick the instantiation.
191 DataType dt = (config_size > 0)
192 ? static_cast<DataType>(config[0])
193 : DataType::UINT16;
194 if (dt == DataType::UINT8) stage = new BitpackStage<uint8_t>();
195 else if (dt == DataType::UINT16) stage = new BitpackStage<uint16_t>();
196 else if (dt == DataType::UINT32) stage = new BitpackStage<uint32_t>();
197 else throw std::runtime_error(
198 "Unsupported BitpackStage DataType: "
199 + std::to_string(static_cast<int>(dt)));
200 stage->deserializeHeader(config, config_size);
201 break;
202 }
203
204 case StageType::RZE: {
205 auto* s = new RZEStage();
206 s->deserializeHeader(config, config_size);
207 stage = s;
208 break;
209 }
210
211 case StageType::LORENZO: {
212 DataType dt = (config_size >= sizeof(LorenzoConfig))
213 ? static_cast<DataType>(config[0])
214 : DataType::INT32;
215 if (dt == DataType::INT8) stage = new LorenzoStage<int8_t>();
216 else if (dt == DataType::INT16) stage = new LorenzoStage<int16_t>();
217 else if (dt == DataType::INT32) stage = new LorenzoStage<int32_t>();
218 else if (dt == DataType::INT64) stage = new LorenzoStage<int64_t>();
219 else throw std::runtime_error(
220 "Unsupported LorenzoStage DataType: "
221 + std::to_string(static_cast<int>(dt)));
222 stage->deserializeHeader(config, config_size);
223 break;
224 }
225
226 default:
227 throw std::runtime_error("Unknown stage type: "
228 + std::to_string(static_cast<uint16_t>(type)));
229 }
230
231 return stage;
232}
233
234} // namespace fz
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:38
fz::DifferenceStage
Definition diff.h:48
fz::LorenzoQuantStage
Definition lorenzo_quant.h:86
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:47
fz::Stage
Definition stage.h:30
fz::Stage::deserializeHeader
virtual void deserializeHeader(const uint8_t *header_buffer, size_t size)
Definition stage.h:136
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.
fz::StageType
StageType
Stage type identifiers written into the FZM header.
Definition fzm_format.h:76
fz::DataType
DataType
Element data type identifiers used in buffer and stage descriptors.
Definition fzm_format.h:102
lorenzo_quant.h
Fused Lorenzo predictor and quantizer stage.
lorenzo_stage.h
Plain integer Lorenzo predictor (delta coding / prefix sum). Lossless.
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::createStage
Stage * createStage(StageType type, const uint8_t *config, size_t config_size)
Definition stage_factory.h:35
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[]).