Start of b3d api.

czi/source_code/CMakeLists.txt

@@ -2,6 +2,9 @@ cmake_minimum_required(VERSION 3.0.0)
 
 option(B3D "Build with B3D cuda compression library." OFF)
 
+# At this moment Boost is `must have` because there is filesystem header in use.
+# option(BOOST "Build with boost headers." ON)
+
 if(B3D)
     message(STATUS "Will build with B3D cuda compression library" )
 endif()

czi/source_code/app/CMakeLists.txt

@@ -23,11 +23,9 @@ include_directories(${PROJECT_SOURCE_DIR}/include)
 
 target_link_libraries(${PROJECT_NAME} sub::azgra)
 
-
-
-
 if(B3D)
     set(CMAKE_CXX_FLAGS "-Wall -DBZ_NO_STDIO -DB3D")
+    target_link_libraries(${PROJECT_NAME} B3D_cudaCompress)
 else()
     set(CMAKE_CXX_FLAGS "-Wall -DBZ_NO_STDIO")
 endif()

czi/source_code/app/include/compression/b3d_api.h

+#pragma once
+#ifdef B3D
+
+#include "benchmark_record.h"
+#include <azgra/azgra.h>
+#include <cuda_runtime_api.h>
+#include <cudaCompress/cudaUtil.h>
+#include <cudaCompress/Instance.h>
+#include <cudaCompress/B3D/B3DcompressFunctions.h>
+
+// #include <fstream>
+// #include <string>
+
+// #include "global.h"
+
+// #include <cuda_runtime.h>
+// #include <cuda_profiler_api.h>
+// #include <cudaCompress/B3D/B3DcompressFunctions.h>
+// #include <cudaCompress/Instance.h>
+// #include <cudaCompress/cudaUtil.h>
+
+// #include "tools/imgtools.h"
+
+//using namespace cudaCompress;
+
+static void HandleError(cudaError_t err,
+						const char *file,
+						int line)
+{
+	if (err != cudaSuccess)
+	{
+		printf("%s in %s at line %d\n", cudaGetErrorString(err),
+			   file, line);
+		exit(EXIT_FAILURE);
+	}
+}
+#define HANDLE_ERROR(err) (HandleError(err, __FILE__, __LINE__))
+
+static void check_if_cuda_device_is_avaible(const int requiredCudaDevice)
+{
+	int deviceCount;
+	HANDLE_ERROR(cudaGetDeviceCount(&deviceCount));
+	always_assert(deviceCount > 0 && "No cuda device is avaible!");
+	always_assert(requiredCudaDevice >= 0 && requiredCudaDevice < deviceCount);
+
+	HANDLE_ERROR(cudaSetDevice(requiredCudaDevice));
+
+	cudaDeviceProp deviceProperties;
+	HANDLE_ERROR(cudaGetDeviceProperties(&deviceProperties, requiredCudaDevice));
+
+	always_assert(deviceProperties.major >= 1 && "GPU doesn't support cuda!");
+	always_assert(deviceProperties.major >= 3 && "GPU doesn't support computre 3.0!");
+}
+
+CompressionResult b3d_compression(const int cudaDeviceId, const ByteArray &imageData, const uint bitsPerPixel, const bool verbose)
+{
+	always_assert(bitsPerPixel == 16);
+
+	check_if_cuda_device_is_avaible(cudaDeviceId);
+
+	// TIMING START
+	// cudaEvent_t g_start, g_end;
+	// cudaEventCreate(&g_start);
+	// cudaEventCreate(&g_end);
+	// cudaEventRecord(g_start);
+
+	cudaCompress::Instance *pInstance = nullptr;
+	cudaCompress::Symbol16 *dpSymbols = nullptr;
+
+	size_t shapes[1][3] = {{211, 1600, 768}};
+	size_t chunkshapes[1][3] = {{1, 1600, 768}};
+
+	float time = 0.0f;
+	float readSpeed, writeSpeed, compressionRatio;
+
+	printf_if(verbose, "Starting cuda compression...\n");
+
+	cudaError status;
+
+	//TODO: What is quantization step? Is 0 for lossless compression?
+
+	float quantStep = 0; // (float)quant_steps[iFilter] / 1000.0 * sqrt(conversion) * 0.8;
+
+	// Initialize cudaCompress, allocate GPU resources and upload data.
+	//pInstance = cudaCompress::createInstance(device, 2, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(float), 128, 16);
+	//TODO: Initialize to some default value.
+	pInstance = cudaCompress::createInstance(cudaDeviceId, 2);
+
+	int16_t *dpImage = nullptr;
+	int16_t *dpBuffer = nullptr;
+	int16_t *dpScratch = nullptr;
+	//TODO: Image size for allocation.
+
+	HANDLE_ERROR(cudaMalloc(&dpImage, sizeX * sizeY * sizeZ * sizeof(int16_t)));
+	HANDLE_ERROR(cudaMalloc(&dpScratch, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(float)));
+	HANDLE_ERROR(cudaMalloc(&dpBuffer, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(float)));
+	HANDLE_ERROR(cudaMalloc(&dpSymbols, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(cudaCompress::Symbol16)));
+
+	float file_size = sizeX * sizeY * sizeZ * sizeof(int16_t);
+
+	// create event objects
+	cudaEvent_t start, end;
+	cudaEventCreate(&start);
+	cudaEventCreate(&end);
+
+	uint iterations = iX * iY * iZ;
+
+	// Compress the image.
+	std::vector<std::vector<uint>> bitStream(iterations);
+	cudaPos offset = {0};
+
+	//start 3d chunked compressing
+	cudaEventRecord(start);
+	//cutilDeviceInitS(device);
+	for (size_t rep = 0; rep < repetitions; rep++)
+	{
+		//cutilDeviceInitS(device);
+		cudaMemcpy(dpImage, image.data(), sizeX * sizeY * sizeZ * sizeof(int16_t), cudaMemcpyHostToDevice);
+
+		for (size_t i = 0; i < iterations; i++)
+		{
+			//cutilDeviceInitS(device);
+			cudaMemset(dpSymbols, 0, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(cudaCompress::Symbol16));
+			if (quantStep == 0)
+				compressImageLL(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, dpBuffer, dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], tiles[iFilter]);
+			else
+				compressImage(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, (float *)dpBuffer, (float *)dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], quantStep, bgLevels[iFilter], tiles[iFilter]);
+			//cudaMemcpy(signs.data() + sizeX*sizeY*i, dpSigns, sizeX * sizeY * sizeof(int16_t), cudaMemcpyDeviceToHost);
+		}
+	}
+	cudaEventRecord(end);
+	cudaEventSynchronize(end);
+	cudaEventElapsedTime(&time, start, end);
+
+	// Write compression rate to stdout.
+	unsigned int compressedSize = 0;
+	for (size_t i = 0; i < iterations; i++)
+	{
+		compressedSize += bitStream[i].size() * sizeof(uint);
+	}
+
+	float ratio = float(compressedSize) / float(sizeX * sizeY * sizeZ * sizeof(int16_t));
+	compression_ratio = 1 / ratio;
+	printf("Compressed size: %.2f kB  (%.2f%%, %.4f)\n", compressedSize / 1024.0f, ratio * 100, 1 / ratio);
+	printf("Compression time: %.2f ms\n", time / repetitions);
+	write_speed = file_size / 1024.0 / 1024.0 / time * repetitions * 1000;
+	printf("Compression speed: %.2f MB/s\n", write_speed);
+
+	std::ofstream out;
+
+	cudaMemset(dpImage, 0, sizeX * sizeY * sizeof(int16_t));
+
+	std::vector<int16_t> imageReconst(sizeX * sizeY * sizeZ);
+
+	cudaEventRecord(start);
+	for (size_t rep = 0; rep < repetitions; rep++)
+	{
+		for (size_t i = 0; i < iterations; i++)
+		{
+			cudaMemset(dpSymbols, 0, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(cudaCompress::Symbol16));
+			if (quantStep == 0)
+				decompressImageLL(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, dpBuffer, dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], tiles[iFilter]);
+			else
+				decompressImage(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, (float *)dpBuffer, (float *)dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], quantStep, bgLevels[iFilter], tiles[iFilter]);
+		}
+
+		cudaMemcpy(imageReconst.data(), dpImage, sizeX * sizeY * sizeZ * sizeof(int16_t), cudaMemcpyDeviceToHost);
+	}
+	cudaEventRecord(end);
+	cudaEventSynchronize(end);
+	cudaEventElapsedTime(&time, start, end);
+
+	printf("Decompression time: %.2f ms\n", time / repetitions);
+	read_speed = file_size / 1024.0 / 1024.0 / time * repetitions * 1000;
+	printf("Decompression speed: %.2f MB/s\n", read_speed);
+
+	// Download reconstructed image and write to file.
+	double psnr = computePSNR(image.data(), imageReconst.data(), sizeX * sizeY * sizeZ);
+	printf("PSNR: %.2f\n", psnr);
+
+	//out.open(base_folder + "output\\" + files[f] + "_" + filter_names[iFilter] + ".raw", std::ofstream::binary);
+	out.open(base_folder + files[f] + "_" + filter_names[iFilter] + ".raw", std::ofstream::binary);
+	out.write((char *)imageReconst.data(), sizeX * sizeY * sizeZ * sizeof(int16_t));
+	out.close();
+
+	// Cleanup.
+	//cudaFree(dpSigns);
+	cudaFree(dpSymbols);
+	cudaFree(dpImage);
+	cudaFree(dpBuffer);
+	cudaFree(dpScratch);
+
+	cudaCompress::destroyInstance(pInstance);
+
+	cudaEventRecord(g_end);
+	cudaEventSynchronize(g_end);
+	cudaEventElapsedTime(&time, g_start, g_end);
+	return 0;
+}
+/*
+int main()
+{
+	cudaCompress::Instance *pInstance = nullptr; // the cudaCompress Instance.
+	cudaCompress::Symbol16 *dpSymbols = nullptr; // input/output for entropy coder.
+
+	int repetitions = 1;
+	int return_code = 1;
+#ifdef _WIN32
+	//std::string base_folder("R:\\");
+	std::string base_folder("D:\\Documents\\data\\B3D\\benchmarking\\");
+#else
+	std::string base_folder("/home/mor0146/gitlab/B3D/");
+#endif
+	std::string files[NUM_FILES] = {
+		//"drosophila_D2re_BG-_masked24_768x1600x8",
+		"drosophila_D2re_BG-_masked24_768x1600x8"
+		//"drosophila_D2re_BG-_masked24_768x1600x211",
+		//"phallusia_T05_S0CL_masked_1800x1600x241"
+	};
+	size_t shapes[NUM_FILES][3] = {{211, 1600, 768}};
+	size_t chunkshapes[NUM_FILES][3] = {{1, 1600, 768}};
+	//size_t shapes[NUM_FILES][3] = { { 241, 1600, 1800 } };
+
+	unsigned int filters[NUM_FILTERS] = {1, 1, 1};
+	unsigned int quant_steps[NUM_FILTERS] = {0, 1000, 3000};
+	unsigned int bgLevels[NUM_FILTERS] = {0, 0, 0};
+	unsigned int tiles[NUM_FILTERS] = {48, 48, 48};
+	std::string filter_names[NUM_FILTERS] = {"B3D_LL", "B3D_1.0", "B3D_3.0"};
+	// open benhcmark file
+	std::ofstream benchmark("benchmark.csv");
+	// write header
+	benchmark << "\t";
+	for (size_t i = 0; i < NUM_FILTERS; i++)
+	{
+		benchmark << filter_names[i] << "\t\t\t";
+	}
+	benchmark << "\n";
+	benchmark << "filename";
+	for (size_t i = 0; i < NUM_FILTERS; i++)
+	{
+		benchmark << "\tratio\twrite (MB/s)\tread (MB/s)\tpsnr";
+	}
+	benchmark << "\n";
+
+	float time = 0.0f;
+	float read_speed, write_speed, compression_ratio;
+
+	for (size_t f = 0; f < numFiles; f++)
+	{
+		fprintf(stdout, "Testing file %s\n", files[f].c_str());
+		benchmark << files[f];
+
+		//int sizeX = 2048, sizeY = 2048;
+		int sizeX = shapes[f][2], sizeY = shapes[f][1], sizeZ = shapes[f][0];
+		//int sizeX = 100, sizeY = 50, sizeZ = 10;
+		int chunkSizeX = chunkshapes[f][2], chunkSizeY = chunkshapes[f][1], chunkSizeZ = chunkshapes[f][0];
+		bool invDWT = true;
+
+		//size_t dwtLevels = 3;
+
+		int iX = (sizeX + chunkSizeX - 1) / chunkSizeX;
+		int iY = (sizeY + chunkSizeY - 1) / chunkSizeY;
+		int iZ = (sizeZ + chunkSizeZ - 1) / chunkSizeZ;
+
+		int alignedSizeX = iX * chunkSizeX;
+		int alignedSizeY = iY * chunkSizeY;
+		int alignedSizeZ = iZ * chunkSizeZ;
+
+		//int16_t* dpImage = nullptr;
+
+		cudaError status;
+
+		// Read image data from file.
+		std::vector<int16_t> image(sizeX * sizeY * sizeZ);
+		std::ifstream file(base_folder + files[f] + ".raw", std::ifstream::binary);
+		//std::ifstream file("F:/data/gradient_100x50x10.raw", std::ifstream::binary);
+		if (!file.good())
+			return 2;
+		file.read((char *)image.data(), sizeX * sizeY * sizeZ * sizeof(int16_t));
+		file.close();
+
+		//for (size_t i = 0; i < image.size(); i++) {
+		//image[i] = _byteswap_ushort(image[i]);
+		//image[i] += 1000;
+		//}
+
+		for (size_t iFilter = 0; iFilter < NUM_FILTERS; iFilter++)
+		{
+			fprintf(stdout, "  Testing filter %s\n", filter_names[iFilter].c_str());
+
+			float quantStep = (float)quant_steps[iFilter] / 1000.0 * sqrt(conversion) * 0.8;
+			// Initialize cudaCompress, allocate GPU resources and upload data.
+			//cutilDeviceInitS(device);
+			pInstance = cudaCompress::createInstance(device, 2, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(float), 128, 16);
+
+			int16_t *dpImage = nullptr;
+			int16_t *dpBuffer = nullptr;
+			int16_t *dpScratch = nullptr;
+			cudaMalloc(&dpImage, sizeX * sizeY * sizeZ * sizeof(int16_t));
+			cudaMalloc(&dpScratch, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(float));
+			cudaMalloc(&dpBuffer, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(float));
+			cudaMalloc(&dpSymbols, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(cudaCompress::Symbol16));
+
+			float file_size = sizeX * sizeY * sizeZ * sizeof(int16_t);
+
+			//cudaMalloc(&dpScratch, sizeX * sizeY * sizeof(float));
+			//cudaMalloc(&dpBuffer, sizeX * sizeY * sizeof(float));
+
+			// create event objects
+			cudaEvent_t start, end;
+			cudaEventCreate(&start);
+			cudaEventCreate(&end);
+
+			uint iterations = iX * iY * iZ;
+
+			// Compress the image.
+
+			std::vector<std::vector<uint>> bitStream(iterations);
+			//std::vector<uint> bitStream;
+
+			cudaPos offset = {0};
+
+			//std::vector<int16_t> signs(sizeX * sizeY * sizeZ);
+
+			//start 3d chunked compressing
+			cudaEventRecord(start);
+			//cutilDeviceInitS(device);
+			for (size_t rep = 0; rep < repetitions; rep++)
+			{
+				//cutilDeviceInitS(device);
+				cudaMemcpy(dpImage, image.data(), sizeX * sizeY * sizeZ * sizeof(int16_t), cudaMemcpyHostToDevice);
+
+				for (size_t i = 0; i < iterations; i++)
+				{
+					//cutilDeviceInitS(device);
+					cudaMemset(dpSymbols, 0, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(cudaCompress::Symbol16));
+					if (quantStep == 0)
+						compressImageLL(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, dpBuffer, dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], tiles[iFilter]);
+					else
+						compressImage(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, (float *)dpBuffer, (float *)dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], quantStep, bgLevels[iFilter], tiles[iFilter]);
+					//cudaMemcpy(signs.data() + sizeX*sizeY*i, dpSigns, sizeX * sizeY * sizeof(int16_t), cudaMemcpyDeviceToHost);
+				}
+			}
+			cudaEventRecord(end);
+			cudaEventSynchronize(end);
+			cudaEventElapsedTime(&time, start, end);
+
+			// Write compression rate to stdout.
+			unsigned int compressedSize = 0;
+			for (size_t i = 0; i < iterations; i++)
+			{
+				compressedSize += bitStream[i].size() * sizeof(uint);
+			}
+
+			float ratio = float(compressedSize) / float(sizeX * sizeY * sizeZ * sizeof(int16_t));
+			compression_ratio = 1 / ratio;
+			printf("Compressed size: %.2f kB  (%.2f%%, %.4f)\n", compressedSize / 1024.0f, ratio * 100, 1 / ratio);
+			printf("Compression time: %.2f ms\n", time / repetitions);
+			write_speed = file_size / 1024.0 / 1024.0 / time * repetitions * 1000;
+			printf("Compression speed: %.2f MB/s\n", write_speed);
+
+			std::ofstream out;
+
+			//out.open(base_folder + "output\\" + files[f] + "_" + filter_names[iFilter] + "_" + "signs.raw", std::ofstream::binary);
+			//out.write((char*)signs.data(), sizeX * sizeY * sizeZ * sizeof(int16_t));
+			//out.close();
+			//cutilDeviceInitS(device);
+			cudaMemset(dpImage, 0, sizeX * sizeY * sizeof(int16_t));
+			//status = cudaMemset(dppImage.ptr, 0, dppImage.pitch * alignedSizeY * alignedSizeZ);
+
+			std::vector<int16_t> imageReconst(sizeX * sizeY * sizeZ);
+			//std::vector<int16_t> signsReconst(sizeX * sizeY * sizeZ);
+
+			cudaEventRecord(start);
+			//cutilDeviceInitS(device);
+			for (size_t rep = 0; rep < repetitions; rep++)
+			{
+				for (size_t i = 0; i < iterations; i++)
+				{
+					//cutilDeviceInitS(device);
+					cudaMemset(dpSymbols, 0, chunkSizeX * chunkSizeY * chunkSizeZ * sizeof(cudaCompress::Symbol16));
+					if (quantStep == 0)
+						decompressImageLL(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, dpBuffer, dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], tiles[iFilter]);
+					else
+						decompressImage(pInstance, bitStream[i], dpImage + chunkSizeX * chunkSizeY * chunkSizeZ * i, (float *)dpBuffer, (float *)dpScratch, dpSymbols, chunkSizeX, chunkSizeY, chunkSizeZ, filters[iFilter], quantStep, bgLevels[iFilter], tiles[iFilter]);
+
+					//cudaMemcpy(signsReconst.data() + sizeX*sizeY*i, dpSigns, sizeX * sizeY * sizeof(int16_t), cudaMemcpyDeviceToHost);
+				}
+
+				cudaMemcpy(imageReconst.data(), dpImage, sizeX * sizeY * sizeZ * sizeof(int16_t), cudaMemcpyDeviceToHost);
+			}
+			cudaEventRecord(end);
+			cudaEventSynchronize(end);
+			cudaEventElapsedTime(&time, start, end);
+
+			printf("Decompression time: %.2f ms\n", time / repetitions);
+			read_speed = file_size / 1024.0 / 1024.0 / time * repetitions * 1000;
+			printf("Decompression speed: %.2f MB/s\n", read_speed);
+			// Download reconstructed image and write to file.
+			double psnr = computePSNR(image.data(), imageReconst.data(), sizeX * sizeY * sizeZ);
+			printf("PSNR: %.2f\n", psnr);
+
+			//out.open(base_folder + "output\\" + files[f] + "_" + filter_names[iFilter] + "_" + "signsReconst.raw", std::ofstream::binary);
+			//out.write((char*)signsReconst.data(), sizeX * sizeY * sizeZ * sizeof(int16_t));
+			//out.close();
+
+			//out.open(base_folder + "output\\" + files[f] + "_" + filter_names[iFilter] + ".raw", std::ofstream::binary);
+			out.open(base_folder + files[f] + "_" + filter_names[iFilter] + ".raw", std::ofstream::binary);
+			out.write((char *)imageReconst.data(), sizeX * sizeY * sizeZ * sizeof(int16_t));
+			out.close();
+
+			// Cleanup.
+			//cudaFree(dpSigns);
+			cudaFree(dpSymbols);
+			cudaFree(dpImage);
+			cudaFree(dpBuffer);
+			cudaFree(dpScratch);
+
+
+			cudaCompress::destroyInstance(pInstance);
+
+			benchmark << "\t" << compression_ratio << "\t" << write_speed << "\t" << read_speed << "\t" << psnr;
+		} // end filter loop
+		//printf("Complete compression + decompression time: %.f ms.\n", time);
+
+		benchmark << "\n";
+	} // end file loop
+
+	benchmark.close();
+
+	cudaEventRecord(g_end);
+
+	cudaEventSynchronize(g_end);
+	cudaEventElapsedTime(&time, g_start, g_end);
+	return 0;
+}
+*/
+#endif
\ No newline at end of file

czi/source_code/app/include/compression/benchmark.h

 #pragma once
-#include "compressors.h"
 
+#include "compressors.h"
 #include <czi/czi_file.h>
 #include <azgra/stream/memory_bit_stream.h>
 #include <azgra/simple_string.h>
@@ -8,87 +8,6 @@
 #include <iomanip>
 #include <thread>
 
-struct BaseBenchmarkRecord
-{
-    const char *fileName = nullptr;
-    size_t subblockId = 0;
-    const char *pixelType = nullptr;
-    size_t width = 0;
-    size_t height = 0;
-    const char *compressionMethod = nullptr;
-    int compressionLevel = 0;
-    size_t originalSize = 0;
-    size_t compressedSize = 0;
-    size_t zOrderCompressedSize = 0;
-    float compressionRatio = 0.0f;
-    float zOrderCompressionRatio = 0.0f;
-    double compressionTime = 0.0;
-    double zOrderCompressionTime = 0.0;
-
-    BaseBenchmarkRecord() {}
-    BaseBenchmarkRecord(const CompressionResult &dataResult, const CompressionResult &dataZOrderResult)
-    {
-        always_assert(dataResult.originalSize == dataZOrderResult.originalSize);
-        originalSize = dataResult.originalSize;
-
-        compressedSize = dataResult.compressedSize;
-        zOrderCompressedSize = dataZOrderResult.compressedSize;
-
-        compressionRatio = dataResult.compressionRatio;
-        zOrderCompressionRatio = dataZOrderResult.compressionRatio;
-
-        compressionTime = dataResult.compressionTimeMS;
-        zOrderCompressionTime = dataZOrderResult.compressionTimeMS;
-    }
-
-    virtual void set_metadata(const char *fName, size_t subBlockId, const char *pixelType, size_t width, size_t height, const char *cMethod, int cLevel)
-    {
-        this->fileName = fName;
-        this->subblockId = subBlockId;
-        this->pixelType = pixelType;
-        this->width = width;
-        this->height = height;
-        this->compressionMethod = cMethod;
-        this->compressionLevel = cLevel;
-    }
-
-    virtual void write_to_stream(std::ofstream &outStream, const char sep) const
-    {
-        outStream << fileName << sep << subblockId << sep << pixelType << sep << width << sep << height << sep << compressionMethod
-                  << sep << compressionLevel << sep << originalSize << sep << compressedSize << sep << zOrderCompressedSize
-                  << sep << compressionRatio << sep << zOrderCompressionRatio << sep << compressionTime
-                  << sep << zOrderCompressionTime << std::endl;
-    }
-};
-
-struct DiffBenchmarkRecord : BaseBenchmarkRecord
-{
-    size_t refSubblockId = 0;
-    uint channel = 0;
-    const char *diffType = nullptr;
-    uint bitsUsedForEncoding = 0;
-
-    void set_metadata(const char *fName, size_t subBlockId, size_t refSlubblockId, const char *pixelType, size_t width, size_t height, const char *cMethod, int cLevel,
-                      const char *diffType, const uint bitsUsed, const uint channel)
-    {
-        BaseBenchmarkRecord::set_metadata(fName, subBlockId, pixelType, width, height, cMethod, cLevel);
-
-        this->refSubblockId = refSlubblockId;
-        this->diffType = diffType;
-        this->bitsUsedForEncoding = bitsUsed;
-        this->channel = channel;
-    }
-
-    void write_to_stream(std::ofstream &outStream, const char sep) const override
-    {
-        outStream << fileName << sep << channel << sep << subblockId << sep << refSubblockId << sep << pixelType << sep << width
-                  << sep << height << sep << compressionMethod << sep << compressionLevel << sep << diffType
-                  << sep << bitsUsedForEncoding << sep << originalSize << sep << compressedSize << sep << zOrderCompressedSize
-                  << sep << compressionRatio << sep << zOrderCompressionRatio << sep << compressionTime
-                  << sep << zOrderCompressionTime << std::endl;
-    }
-};
-
 // Raw Compression benchmark functions.
 void write_compression_report(const std::vector<BaseBenchmarkRecord> &results, const std::string &reportFile);
 void compression_thread_work(const ByteArray &data, CompressionMethod method, int compressionLevel, CompressionResult &result, const char *info);

czi/source_code/app/include/compression/benchmark_record.h

+#pragma once
+#include <fstream>
+
+struct CompressionResult
+{
+    size_t originalSize;
+    size_t compressedSize;
+    float compressionRatio;
+    float ratioToOriginalSize;
+    double compressionTimeMS;
+
+    CompressionResult()
+    {
+        originalSize = 0;
+        compressedSize = 0;
+        compressionRatio = 0.0f;
+        compressionTimeMS = 0;
+        ratioToOriginalSize = 0;
+    }
+
+    void divide(float x)
+    {
+        originalSize /= x;
+        compressedSize /= x;
+        compressionRatio /= x;
+        ratioToOriginalSize /= x;
+    }
+};
+
+struct BaseBenchmarkRecord
+{
+    const char *fileName = nullptr;
+    size_t subblockId = 0;
+    const char *pixelType = nullptr;
+    size_t width = 0;
+    size_t height = 0;
+    const char *compressionMethod = nullptr;
+    int compressionLevel = 0;
+    size_t originalSize = 0;
+    size_t compressedSize = 0;
+    size_t zOrderCompressedSize = 0;
+    float compressionRatio = 0.0f;
+    float zOrderCompressionRatio = 0.0f;
+    double compressionTime = 0.0;
+    double zOrderCompressionTime = 0.0;
+
+    BaseBenchmarkRecord() {}
+    BaseBenchmarkRecord(const CompressionResult &dataResult, const CompressionResult &dataZOrderResult)
+    {
+        always_assert(dataResult.originalSize == dataZOrderResult.originalSize);
+        originalSize = dataResult.originalSize;
+
+        compressedSize = dataResult.compressedSize;
+        zOrderCompressedSize = dataZOrderResult.compressedSize;
+
+        compressionRatio = dataResult.compressionRatio;
+        zOrderCompressionRatio = dataZOrderResult.compressionRatio;
+
+        compressionTime = dataResult.compressionTimeMS;
+        zOrderCompressionTime = dataZOrderResult.compressionTimeMS;
+    }
+
+    virtual void set_metadata(const char *fName, size_t subBlockId, const char *pixelType, size_t width, size_t height, const char *cMethod, int cLevel)
+    {
+        this->fileName = fName;
+        this->subblockId = subBlockId;
+        this->pixelType = pixelType;
+        this->width = width;
+        this->height = height;
+        this->compressionMethod = cMethod;
+        this->compressionLevel = cLevel;
+    }
+
+    virtual void write_to_stream(std::ofstream &outStream, const char sep) const
+    {
+        outStream << fileName << sep << subblockId << sep << pixelType << sep << width << sep << height << sep << compressionMethod
+                  << sep << compressionLevel << sep << originalSize << sep << compressedSize << sep << zOrderCompressedSize
+                  << sep << compressionRatio << sep << zOrderCompressionRatio << sep << compressionTime
+                  << sep << zOrderCompressionTime << std::endl;
+    }
+};
+
+struct DiffBenchmarkRecord : BaseBenchmarkRecord
+{
+    size_t refSubblockId = 0;
+    uint channel = 0;
+    const char *diffType = nullptr;
+    uint bitsUsedForEncoding = 0;
+
+    void set_metadata(const char *fName, size_t subBlockId, size_t refSlubblockId, const char *pixelType, size_t width, size_t height, const char *cMethod, int cLevel,
+                      const char *diffType, const uint bitsUsed, const uint channel)
+    {
+        BaseBenchmarkRecord::set_metadata(fName, subBlockId, pixelType, width, height, cMethod, cLevel);
+
+        this->refSubblockId = refSlubblockId;
+        this->diffType = diffType;
+        this->bitsUsedForEncoding = bitsUsed;
+        this->channel = channel;
+    }
+
+    void write_to_stream(std::ofstream &outStream, const char sep) const override
+    {
+        outStream << fileName << sep << channel << sep << subblockId << sep << refSubblockId << sep << pixelType << sep << width
+                  << sep << height << sep << compressionMethod << sep << compressionLevel << sep << diffType
+                  << sep << bitsUsedForEncoding << sep << originalSize << sep << compressedSize << sep << zOrderCompressedSize
+                  << sep << compressionRatio << sep << zOrderCompressionRatio << sep << compressionTime
+                  << sep << zOrderCompressionTime << std::endl;
+    }
+};

czi/source_code/app/include/compression/compressors.h

@@ -3,6 +3,7 @@
 #include <azgra/utilities/z_order.h>
 #include <azgra/utilities/Stopwatch.h>
 #include <custom_types.h>
+#include "benchmark_record.h"
 
 namespace library_zlib
 {
@@ -27,33 +28,6 @@ enum CompressionMethod
 };
 
 const char *compression_method_str(const CompressionMethod cm);
-
-struct CompressionResult
-{
-    size_t originalSize;
-    size_t compressedSize;
-    float compressionRatio;
-    float ratioToOriginalSize;
-    double compressionTimeMS;
-
-    CompressionResult()
-    {
-        originalSize = 0;
-        compressedSize = 0;
-        compressionRatio = 0.0f;
-        compressionTimeMS = 0;
-        ratioToOriginalSize = 0;
-    }
-
-    void divide(float x)
-    {
-        originalSize /= x;
-        compressedSize /= x;
-        compressionRatio /= x;
-        ratioToOriginalSize /= x;
-    }
-};
-
 constexpr size_t MAX_LITERAL_COUNT = 255;
 constexpr size_t MAX_RUN_COUNT = 255;
 constexpr size_t MAX_LOOKBACK_COUNT = 255;

czi/source_code/app/main.cpp

@@ -21,14 +21,17 @@ CompressionMethod get_chosen_compression_method(args::Flag &gzip, args::Flag &lz
 
 void show_version()
 {
-#if DEBUG
-    printf("DEBUG\n");
-#else
-    printf("RELEASE\n");
-#endif
+    bool b3d = false;
+    bool debug = false;
+
 #ifdef B3D
-    printf("- With B3D compresion library.\n");
+    b3d = true;
 #endif
+#if DEBUG
+    debug = true;
+#endif
+
+    printf("%s version, with: \n B3D - %s\n", debug ? "DEBUG" : "RELEASE", b3d ? "ON" : "OFF");
 }
 
 int main(int argc, char **argv)