jfjoch_fpga_stills_test: the file's module layout, the firmware's generator limits
- Layout from the file: its NXmx module groups, else the modules the gaps of its pixel mask mark (any placement and orientation of 1030 x 514 modules); a module without a stated readout direction is read out along its long side from its box's corner (the multipixels are symmetric, so the frames are the same). The file's modules also go to the analysis. - Distinct images per card = (its generator module frames - 1) / its modules, the run takes the smallest over the cards, at most FPGA_INTERNAL_GENERATOR_MAX_IMAGES (frame_cell, 128) and within FPGA_INTERNAL_GENERATOR_MAX_MODULE_FRAMES (mem_cell, 1024). The broker's 64-image limit stays: DetectorSettings::InternalGeneratorImages takes the maximum as a parameter, defaulting to it. The mapping (cards, modules, module frames used) is printed at start. - -K defaults to 64 MiB of mock generator memory = 128 module frames. - Squeeze round-trip tests for a 4M and a 9M layout and a 16-module layout with turned and standing modules. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UqXYdHHZ4cogS1mrGUtfN7
This commit is contained in:
1 parent
4c8af0dbc1
commit
1135beb74e
8 files changed
+134
-57
No files matched your search
@@ -13,9 +13,9 @@ DetectorSettings &DetectorSettings::InternalGeneratorEnable(bool input) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
DetectorSettings &DetectorSettings::InternalGeneratorImages(int64_t input) {
|
||||
DetectorSettings &DetectorSettings::InternalGeneratorImages(int64_t input, int64_t max_images) {
|
||||
check_min("Internal packet generator images", input, 1);
|
||||
check_max("Internal packet generator images", input, 64);
|
||||
check_max("Internal packet generator images", input, max_images);
|
||||
internal_fpga_packet_generator_images = input;
|
||||
return *this;
|
||||
}
|
||||
|
||||
@@ -37,7 +37,9 @@ class DetectorSettings {
|
||||
DetectorTiming timing = DetectorTiming::Trigger;
|
||||
public:
|
||||
DetectorSettings& InternalGeneratorEnable(bool input);
|
||||
DetectorSettings& InternalGeneratorImages(int64_t input);
|
||||
// The broker's limit; the firmware's own is FPGA_INTERNAL_GENERATOR_MAX_IMAGES
|
||||
static constexpr int64_t DefaultMaxInternalGeneratorImages = 64;
|
||||
DetectorSettings& InternalGeneratorImages(int64_t input, int64_t max_images = DefaultMaxInternalGeneratorImages);
|
||||
DetectorSettings& StorageCells(int64_t input);
|
||||
DetectorSettings& StorageCellStart(int64_t input);
|
||||
DetectorSettings& StorageCellDelay(const std::chrono::nanoseconds &input);
|
||||
|
||||
@@ -1094,8 +1094,8 @@ float DiffractionExperiment::GetPhotonEnergyForConversion_keV() const {
|
||||
return GetIncidentEnergy_keV();
|
||||
}
|
||||
|
||||
DiffractionExperiment &DiffractionExperiment::InternalPacketGeneratorImages(int64_t input) {
|
||||
detector_settings.InternalGeneratorImages(input);
|
||||
DiffractionExperiment &DiffractionExperiment::InternalPacketGeneratorImages(int64_t input, int64_t max_images) {
|
||||
detector_settings.InternalGeneratorImages(input, max_images);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
@@ -119,7 +119,8 @@ public:
|
||||
DiffractionExperiment& ZMQPreviewPeriod(const std::optional<std::chrono::microseconds> &input);
|
||||
|
||||
DiffractionExperiment& UseInternalPacketGenerator(bool input);
|
||||
DiffractionExperiment& InternalPacketGeneratorImages(int64_t input);
|
||||
DiffractionExperiment& InternalPacketGeneratorImages(int64_t input,
|
||||
int64_t max_images = DetectorSettings::DefaultMaxInternalGeneratorImages);
|
||||
DiffractionExperiment& MaskModuleEdges(bool input);
|
||||
DiffractionExperiment& MaskChipEdges(bool input);
|
||||
|
||||
|
||||
+10
-5
@@ -77,8 +77,10 @@ Measures rugnux live stills on the FPGA card(s), with a stored dataset standing
|
||||
jfjoch_fpga_stills_test [-i <images>] [-s <cards>] [-N <threads>] [-B <MiB>] [-C a,b,c,al,be,ga] [-X <indexer>] [-p <slots>] [-F] [-K[<MiB>]] <master.h5>
|
||||
```
|
||||
|
||||
- The dataset must be a stored JUNGFRAU dataset, assembled with 8/36 pixel module gaps (as Jungfraujoch
|
||||
writes it); the module layout is derived from the image size. Each image is folded back into module
|
||||
- The dataset must be a stored JUNGFRAU dataset with its modules assembled (1030 x 514 each, any placement
|
||||
and orientation): the layout is the file's - its NXmx module groups, else the modules the gaps of its pixel
|
||||
mask mark (where the file does not give a module's readout direction, the module is read out from the
|
||||
top-left corner of its box; the multipixels are symmetric, so the frames are the same). Each image is folded back into module
|
||||
frames, the inverse of the host's geometry transformation: the inter-chip pixels the assembled image
|
||||
spreads one raw pixel over (2, or 4 at a chip corner) are summed back into it (the split conserves
|
||||
the count); where one of them is an error, gap or masked pixel the raw pixel is an error pixel, where
|
||||
@@ -89,8 +91,11 @@ jfjoch_fpga_stills_test [-i <images>] [-s <cards>] [-N <threads>] [-B <MiB>] [-C
|
||||
`JFJochReceiverFPGA`'s own live stills, for comparison). Beam centre, distance, energy and the cell
|
||||
come from the file (`-C` overrides the cell; without one the frames are indexed de novo). Nothing is
|
||||
written.
|
||||
- The generator holds only as many images as its card memory (and the 64-image limit of the
|
||||
generator setting) allows: the first ones of the file, cycled for the whole run of `-i` images
|
||||
- Each card's generator holds module frames of its own modules only: as many images as its memory holds
|
||||
module frames (less one, which the host keeps free) divided by the modules of that card - e.g. 128 module
|
||||
frames: a 9M (18 modules) on one card 7 images, on two cards of 9 modules 14. The run takes the smallest
|
||||
over the cards (and at most 128, the firmware's image counter; the broker's limit of 64 images does not
|
||||
apply here) and prints the mapping. These are the first ones of the file, cycled for the whole run of `-i` images
|
||||
(default: as many as the file has). **Images repeat**, so throughput, latency, spots per image and
|
||||
indexing rate are meaningful, the merge and its statistics are not. The generator sends as fast as
|
||||
the card can, faster than a detector: images the host cannot keep up with are dropped by the puller
|
||||
@@ -103,7 +108,7 @@ jfjoch_fpga_stills_test [-i <images>] [-s <cards>] [-N <threads>] [-B <MiB>] [-C
|
||||
(`StillsGPUAnalysis::PREPASS_IMAGES`) in half its slots.
|
||||
- `-K` runs on the mock of the card (`MockAcquisitionDevice`, which returns the generator's frames as
|
||||
loaded) instead of `/dev/jfjoch*`, so the program runs without a card; the optional value is the mock's
|
||||
generator memory in MiB.
|
||||
generator memory in MiB (default 64 MiB = 128 module frames).
|
||||
- To compare with the offline analysis of the same images, run it with `-i` equal to the number of
|
||||
distinct images it reports (no repeats) and `rugnux --force-still -e <that number - 1>` or
|
||||
`jfjoch_stills_gpu_replay -n <that number>` on the same file.
|
||||
|
||||
@@ -58,6 +58,9 @@ typedef __u64 uint64_t;
|
||||
// MAX_MODULES_FPGA is read by FPGA setup scripts and must be decimal, no expression!
|
||||
#define MAX_MODULES_FPGA 32
|
||||
#define MAX_FPGA_SUMMATION 256
|
||||
// frame_generator.cpp: images in its memory (frame_cell, 7 bits) and module frames it addresses (mem_cell, 10 bits)
|
||||
#define FPGA_INTERNAL_GENERATOR_MAX_IMAGES 128
|
||||
#define FPGA_INTERNAL_GENERATOR_MAX_MODULE_FRAMES 1024
|
||||
|
||||
#define ADU_HISTO_BIN_WIDTH 32
|
||||
#define ADU_HISTO_BIN_COUNT (65536/ ADU_HISTO_BIN_WIDTH)
|
||||
|
||||
@@ -518,37 +518,65 @@ TEST_CASE("RawToConvertedCoordinate_Coord","[RawToConvertedGeometry]") {
|
||||
REQUIRE(Catch::Approx(c.y) == CONVERTED_MODULE_LINES * 2 + 36 - 1 - 300.25 - 2); // line 300 becomes 302 due to 1 chip boundary
|
||||
}
|
||||
|
||||
TEST_CASE("RawToConvertedGeometry_SqueezeToRawGeometry","[RawToConvertedGeometry]") {
|
||||
namespace {
|
||||
// Assembled with the multipixels split, then squeezed back: the raw frames, where the split divides evenly
|
||||
DiffractionExperiment x(DetJF(4, 2, 8, 36, true));
|
||||
x.PixelSigned(true).BitDepthImage(16);
|
||||
void CheckSqueezeRoundTrip(const DetectorSetup &detector) {
|
||||
DiffractionExperiment x(detector);
|
||||
x.PixelSigned(true).BitDepthImage(16);
|
||||
|
||||
std::vector<int16_t> raw(x.GetModulesNum() * RAW_MODULE_SIZE);
|
||||
for (size_t i = 0; i < raw.size(); i++)
|
||||
raw[i] = static_cast<int16_t>(4 * (i % 5000) - 400);
|
||||
raw[255 * RAW_MODULE_COLS + 255] = INT16_MIN; // error, chip corner
|
||||
raw[RAW_MODULE_SIZE + 10 * RAW_MODULE_COLS + 256] = INT16_MAX; // saturated, multipixel
|
||||
std::vector<int16_t> raw(x.GetModulesNum() * RAW_MODULE_SIZE);
|
||||
for (size_t i = 0; i < raw.size(); i++)
|
||||
raw[i] = static_cast<int16_t>(4 * (i % 5000) - 400);
|
||||
raw[255 * RAW_MODULE_COLS + 255] = INT16_MIN; // error, chip corner
|
||||
raw[RAW_MODULE_SIZE + 10 * RAW_MODULE_COLS + 256] = INT16_MAX; // saturated, multipixel
|
||||
|
||||
std::vector<int32_t> image(x.GetPixelsNum(), INT32_MIN);
|
||||
for (int m = 0; m < x.GetModulesNum(); m++)
|
||||
TransferModuleAdjustMultipixels<int32_t, int16_t>(image.data(), raw.data() + m * RAW_MODULE_SIZE,
|
||||
x.GetModuleSlowDirectionStep(m), INT16_MIN, INT16_MAX,
|
||||
x.GetModuleFastDirectionStep(m), x.GetPixel0OfModuleConv(m));
|
||||
for (auto &v: image) {
|
||||
if (v == INT16_MIN)
|
||||
v = INT32_MIN;
|
||||
else if (v == INT16_MAX)
|
||||
v = INT32_MAX;
|
||||
std::vector<int32_t> image(x.GetPixelsNum(), INT32_MIN);
|
||||
for (int m = 0; m < x.GetModulesNum(); m++)
|
||||
TransferModuleAdjustMultipixels<int32_t, int16_t>(image.data(), raw.data() + m * RAW_MODULE_SIZE,
|
||||
x.GetModuleSlowDirectionStep(m), INT16_MIN, INT16_MAX,
|
||||
x.GetModuleFastDirectionStep(m),
|
||||
x.GetPixel0OfModuleConv(m));
|
||||
for (auto &v: image) {
|
||||
if (v == INT16_MIN)
|
||||
v = INT32_MIN;
|
||||
else if (v == INT16_MAX)
|
||||
v = INT32_MAX;
|
||||
}
|
||||
|
||||
std::vector<int16_t> squeezed(raw.size());
|
||||
SqueezeToRawGeometry<int16_t, int32_t>(x, squeezed.data(), image.data(), INT32_MIN, INT32_MAX,
|
||||
INT16_MIN, INT16_MAX);
|
||||
CHECK(squeezed == raw);
|
||||
|
||||
// A sum past the 16-bit range is saturated
|
||||
image[x.GetPixel0OfModuleConv(0)] = 40000;
|
||||
SqueezeToRawGeometry<int16_t, int32_t>(x, squeezed.data(), image.data(), INT32_MIN, INT32_MAX,
|
||||
INT16_MIN, INT16_MAX);
|
||||
CHECK(squeezed[0] == INT16_MAX);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<int16_t> squeezed(raw.size());
|
||||
SqueezeToRawGeometry<int16_t, int32_t>(x, squeezed.data(), image.data(), INT32_MIN, INT32_MAX,
|
||||
INT16_MIN, INT16_MAX);
|
||||
CHECK(squeezed == raw);
|
||||
TEST_CASE("RawToConvertedGeometry_SqueezeToRawGeometry_4M","[RawToConvertedGeometry]") {
|
||||
CheckSqueezeRoundTrip(DetJF(8, 2, 8, 36, true));
|
||||
}
|
||||
|
||||
// A sum past the 16-bit range is saturated
|
||||
image[x.GetPixel0OfModuleConv(0)] = 40000;
|
||||
SqueezeToRawGeometry<int16_t, int32_t>(x, squeezed.data(), image.data(), INT32_MIN, INT32_MAX,
|
||||
INT16_MIN, INT16_MAX);
|
||||
CHECK(squeezed[0] == INT16_MAX);
|
||||
TEST_CASE("RawToConvertedGeometry_SqueezeToRawGeometry_9M","[RawToConvertedGeometry]") {
|
||||
CheckSqueezeRoundTrip(DetJF(18, 3, 8, 36, true));
|
||||
}
|
||||
|
||||
TEST_CASE("RawToConvertedGeometry_SqueezeToRawGeometry_16_modules_turned","[RawToConvertedGeometry]") {
|
||||
// 12 modules in rows of two, every other row read out the other way, and 4 standing modules beside them
|
||||
using Direction = DetectorModuleGeometry::Direction;
|
||||
std::vector<DetectorModuleGeometry> modules;
|
||||
for (int row = 0; row < 6; row++)
|
||||
for (int col = 0; col < 2; col++) {
|
||||
if (row % 2 == 0)
|
||||
modules.emplace_back(col * 1038, row * 550, Direction::Xpos, Direction::Ypos);
|
||||
else
|
||||
modules.emplace_back(col * 1038 + 1029, row * 550 + 513, Direction::Xneg, Direction::Yneg);
|
||||
}
|
||||
for (int row = 0; row < 2; row++)
|
||||
for (int col = 0; col < 2; col++)
|
||||
modules.emplace_back(2076 + col * 522 + 513, row * 1038, Direction::Ypos, Direction::Xneg);
|
||||
CheckSqueezeRoundTrip(DetJF(DetectorGeometryModular(modules)));
|
||||
}
|
||||
@@ -22,8 +22,9 @@
|
||||
|
||||
void print_usage(Logger &logger) {
|
||||
logger.Info("Usage ./jfjoch_fpga_stills_test {<options>} <master.h5>");
|
||||
logger.Info("The dataset: JUNGFRAU modules, assembled with 8/36 pixel gaps. Its first images are loaded into");
|
||||
logger.Info("the card's internal generator, which cycles through them: images repeat, so throughput, latency");
|
||||
logger.Info("The dataset: JUNGFRAU modules, as the file states them (module groups, else the gaps of its mask).");
|
||||
logger.Info("Its first images - per card, as many as its generator memory holds of that card's modules - are");
|
||||
logger.Info("loaded into the cards' internal generators, which cycle through them: images repeat, so throughput, latency");
|
||||
logger.Info("and indexing rate are meaningful, the merge and its statistics are not. See docs/TOOLS.md.");
|
||||
logger.Info("Options:");
|
||||
logger.Info(" -v Verbose");
|
||||
@@ -36,15 +37,44 @@ void print_usage(Logger &logger) {
|
||||
logger.Info(" -t<num> Indexing thread pool size (default: 4)");
|
||||
logger.Info(" -p<num> FPGAImagePuller slots (default 128)");
|
||||
logger.Info(" -F JFJochReceiverFPGA's own live stills instead of FPGAImagePuller");
|
||||
logger.Info(" -K{<MiB>} Mock of the card instead of /dev/jfjoch* (optional: its generator memory, default 32 MiB)");
|
||||
logger.Info(" -K{<MiB>} Mock of the card instead of /dev/jfjoch* (optional: its generator memory, default 64 MiB =");
|
||||
logger.Info(" 128 module frames)");
|
||||
}
|
||||
|
||||
// The images the internal generator holds for this run: what the card memory holds, at most what the run needs
|
||||
// A module the file gives the readout of keeps it; one it does not (taken from the gaps of its mask, +x +y) is read
|
||||
// out from the top-left corner of its box, along its 1030-pixel side. As the multipixels are symmetric in a module,
|
||||
// which corner it is does not change the frames the card returns.
|
||||
std::optional<DetectorGeometryModular> GeometryFromModules(const DetectorModules &modules) {
|
||||
using Direction = DetectorModuleGeometry::Direction;
|
||||
auto along_x = [](Direction d) { return (d == Direction::Xpos) || (d == Direction::Xneg); };
|
||||
|
||||
std::vector<DetectorModuleGeometry> ret;
|
||||
for (const auto &m: modules.Get()) {
|
||||
if ((m.width == CONVERTED_MODULE_COLS) && (m.height == CONVERTED_MODULE_LINES) && along_x(m.fast))
|
||||
ret.emplace_back(m.ReadoutX0(), m.ReadoutY0(), m.fast, m.slow);
|
||||
else if ((m.width == CONVERTED_MODULE_LINES) && (m.height == CONVERTED_MODULE_COLS) && !along_x(m.fast))
|
||||
ret.emplace_back(m.ReadoutX0(), m.ReadoutY0(), m.fast, m.slow);
|
||||
else if ((m.width == CONVERTED_MODULE_LINES) && (m.height == CONVERTED_MODULE_COLS))
|
||||
ret.emplace_back(m.x0, m.y0, Direction::Ypos, Direction::Xpos);
|
||||
else
|
||||
return {};
|
||||
}
|
||||
if (ret.empty())
|
||||
return {};
|
||||
return DetectorGeometryModular(ret);
|
||||
}
|
||||
|
||||
// The images the internal generator holds for this run: what the card memory and the firmware hold (not the broker's
|
||||
// limit), at most what the run needs
|
||||
int64_t GeneratorImages(AcquisitionDeviceGroup &aq_devices, const DiffractionExperiment &x, int64_t file_images) {
|
||||
int64_t ret = std::min<int64_t>(file_images, x.GetImageNum());
|
||||
ret = std::min<int64_t>(ret, 64); // DetectorSettings::InternalGeneratorImages
|
||||
for (int i = 0; i < x.GetDataStreamsNum(); i++)
|
||||
ret = std::min<int64_t>(ret, (aq_devices[i].GetInternalGeneratorModuleFrames() - 1) / x.GetModulesNum(i));
|
||||
ret = std::min<int64_t>(ret, FPGA_INTERNAL_GENERATOR_MAX_IMAGES);
|
||||
for (int i = 0; i < x.GetDataStreamsNum(); i++) {
|
||||
// CheckInternalGeneratorFrame leaves the last module frame of the card memory free
|
||||
const int64_t module_frames = std::min<int64_t>(aq_devices[i].GetInternalGeneratorModuleFrames() - 1,
|
||||
FPGA_INTERNAL_GENERATOR_MAX_MODULE_FRAMES);
|
||||
ret = std::min<int64_t>(ret, module_frames / x.GetModulesNum(i));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -59,16 +89,17 @@ bool RunDataset(Logger &logger, AcquisitionDeviceGroup &aq_devices, const std::s
|
||||
const auto dataset = reader.GetDataset();
|
||||
const auto &file_x = dataset->experiment;
|
||||
|
||||
// JUNGFRAU modules (1030 x 514 assembled) with the gaps of DetectorGeometryModular as the PSI detectors have them
|
||||
const int64_t width = file_x.GetXPixelsNum(), height = file_x.GetYPixelsNum();
|
||||
const int64_t module_x = CONVERTED_MODULE_COLS + 8, module_y = CONVERTED_MODULE_LINES + 36;
|
||||
const int64_t cols = (width + 8) / module_x, rows = (height + 36) / module_y;
|
||||
if ((cols * module_x - 8 != width) || (rows * module_y - 36 != height)) {
|
||||
logger.Error("Image {} x {} is not a JUNGFRAU module layout with 8/36 pixel gaps", width, height);
|
||||
// The modules as the file states them (module groups, else the gaps of its mask)
|
||||
const auto geometry = GeometryFromModules(file_x.GetModules());
|
||||
if (!geometry || (geometry->GetWidth(true) != file_x.GetXPixelsNum())
|
||||
|| (geometry->GetHeight(true) != file_x.GetYPixelsNum())) {
|
||||
logger.Error("The file does not state JUNGFRAU modules (1030 x 514) that make up its {} x {} image",
|
||||
file_x.GetXPixelsNum(), file_x.GetYPixelsNum());
|
||||
return false;
|
||||
}
|
||||
|
||||
DiffractionExperiment x(DetJF(cols * rows, cols, 8, 36, true));
|
||||
DiffractionExperiment x(DetJF(geometry.value()));
|
||||
x.Modules(file_x.GetModules());
|
||||
x.ImagesPerTrigger(nimages.value_or(reader.GetNumberOfImages())).NumTriggers(1).PedestalG0Frames(0)
|
||||
.UseInternalPacketGenerator(true).DataStreams(nstreams);
|
||||
// The card returns the frames as loaded; the host assembles them as signed 16-bit photon counts
|
||||
@@ -86,14 +117,22 @@ bool RunDataset(Logger &logger, AcquisitionDeviceGroup &aq_devices, const std::s
|
||||
logger.Error("The card memory cannot hold one image of {} modules", x.GetModulesNum());
|
||||
return false;
|
||||
}
|
||||
x.InternalPacketGeneratorImages(generator_images);
|
||||
x.InternalPacketGeneratorImages(generator_images, FPGA_INTERNAL_GENERATOR_MAX_IMAGES);
|
||||
|
||||
PixelMask mask(x);
|
||||
if (dataset->pixel_mask->GetMask().size() == x.GetPixelsNum())
|
||||
mask.LoadUserMask(x, dataset->pixel_mask->GetMask());
|
||||
|
||||
logger.Info("Dataset {}: {} images of {} modules ({} x {}), {} distinct ones in the generator, {} in the run",
|
||||
file, reader.GetNumberOfImages(), x.GetModulesNum(), cols, rows, generator_images, x.GetImageNum());
|
||||
logger.Info("Dataset {}: {} images of {} modules, {} distinct ones in the generator, {} in the run",
|
||||
file, reader.GetNumberOfImages(), x.GetModulesNum(), generator_images, x.GetImageNum());
|
||||
for (int i = 0; i < x.GetDataStreamsNum(); i++)
|
||||
logger.Info(" card {}: modules {}-{}, generator memory {} module frames, {} used", i,
|
||||
x.GetFirstModuleOfDataStream(i), x.GetFirstModuleOfDataStream(i) + x.GetModulesNum(i) - 1,
|
||||
aq_devices[i].GetInternalGeneratorModuleFrames(), x.GetModulesNum(i) * generator_images);
|
||||
for (int m = 0; m < x.GetModulesNum(); m++)
|
||||
logger.Debug(" module {}: pixel 0 at ({}, {}), fast step {}, slow step {}", m,
|
||||
x.GetPixel0OfModuleConv(m) % x.GetXPixelsNum(), x.GetPixel0OfModuleConv(m) / x.GetXPixelsNum(),
|
||||
x.GetModuleFastDirectionStep(m), x.GetModuleSlowDirectionStep(m));
|
||||
logger.Info("Mode: {}, rugnux live stills", fpga_receiver ? "JFJochReceiverFPGA"
|
||||
: fmt::format("FPGAImagePuller ({} slots)", puller_slots));
|
||||
|
||||
@@ -237,8 +276,7 @@ int main(int argc, char **argv) {
|
||||
fpga_receiver = true;
|
||||
break;
|
||||
case 'K':
|
||||
mock_card_MiB = (optarg != nullptr) ? atol(optarg)
|
||||
: MockAcquisitionDevice::DefaultCardMemoryBytes / (1024 * 1024);
|
||||
mock_card_MiB = (optarg != nullptr) ? atol(optarg) : 64;
|
||||
break;
|
||||
default:
|
||||
print_usage(logger);
|
||||
|
||||
Reference in new issue
Block a user