Function TEST_F

publication/source_code/bench_compression_ratio/alp32.cpp:130–215

* Test to encode and decode whole datasets using ALP RD (aka ALP Cutter) * This test will output and write a file with the estimated bits/value after compression with alp */

 * This test will output and write a file with the estimated bits/value after compression with alp
 */
TEST_F(alp32_test, test_alprd32_on_whole_datasets) {
	std::ofstream ofile(alp_bench::get_paths().result_dir_path + "compression_ratio_result/float/alp.csv", std::ios::out);
	ofile << "dataset,size,rowgroups_count,vectors_count\n";

	for (auto& dataset : alp_bench::get_sp_datasets()) {
		if (!dataset.suitable_for_cutting) { continue; }

		std::cout << dataset.name << std::endl;

		std::vector<alp_bench::VectorMetadata> compression_metadata;
		size_t                                 tuples_count;
		auto*             data_column     = mapper::mmap_file<float>(tuples_count, dataset.binary_file_path);
		float             value_to_encode = 0.0;
		size_t            vector_idx {0};
		size_t            rowgroup_counter {0};
		size_t            rowgroup_offset {0};
		alp::state<float> stt;
		size_t            rowgroups_count {1};
		size_t            vectors_count {1};

		/* Init */
		alp::encoder<float>::init(data_column, rowgroup_offset, tuples_count, smp_arr, stt);

		ASSERT_EQ(stt.scheme, alp::Scheme::ALP_RD);

		alp::rd_encoder<float>::init(data_column, rowgroup_offset, tuples_count, smp_arr, stt);

		/* Encode - Decode - Validate. */
		for (size_t i = 0; i < tuples_count; i++) {
			value_to_encode     = data_column[i];
			dbl_arr[vector_idx] = value_to_encode;
			vector_idx          = vector_idx + 1;
			rowgroup_offset     = rowgroup_offset + 1;
			rowgroup_counter    = rowgroup_counter + 1;

			if (vector_idx != VECTOR_SIZE) { continue; }

			if (rowgroup_counter == ROWGROUP_SIZE) {
				rowgroup_counter = 0;
				rowgroups_count  = rowgroups_count + 1;
			}

			// Encode
			alp::rd_encoder<float>::encode(dbl_arr, rd_exc_arr, pos_arr, exc_c_arr, right_arr, left_arr, stt);
			uint32_t right_for_base = 0;
			ffor::   ffor(right_arr, ffor_right_arr, stt.right_bit_width, &right_for_base);
			ffor::   ffor(left_arr, ffor_left_arr, stt.left_bit_width, &stt.left_for_base);

			// Decode
			unffor::unffor(ffor_right_arr, unffor_right_arr, stt.right_bit_width, &right_for_base);
			unffor::unffor(ffor_left_arr, unffor_left_arr, stt.left_bit_width, &stt.left_for_base);
			alp::rd_encoder<float>::decode(
			    glue_arr, unffor_right_arr, unffor_left_arr, rd_exc_arr, pos_arr, exc_c_arr, stt);

			auto* dbl_glue_arr = reinterpret_cast<float*>(glue_arr);
			for (size_t j = 0; j < VECTOR_SIZE; ++j) {
				auto l = dbl_arr[j];
				auto r = dbl_glue_arr[j];