void benchFilter(const std::vector<byte>& data) {
CM<kCMTypeMax> comp(6);
// data = randomArray(kBenchDataSize);
check(!data.empty());
const uint64_t expected_sum = std::accumulate(data.begin(), data.end(), 0UL);
std::vector<byte> out_data;
out_data.resize(20 * MB + static_cast<uint32_t>(data.size() * FilterType::getMaxExpansion() * 1.2));
uint64_t start = clock();
uint64_t write_count;
uint64_t old_sum = 0;
uint32_t best_size = std::numeric_limits<uint32_t>::max();
uint32_t best_spec;
for (uint32_t i = 0; i < kIterations; ++i) {
WriteMemoryStream wms(&out_data[0]);
ReadMemoryStream rms(&data);
FilterType f(&rms); // , 1 + (i & 3), 1 + (i / 4));
// f.setSpecific(100 + i);
comp.setOpt(i);
clock_t start = clock();
comp.compress(&f, &wms, std::numeric_limits<uint64_t>::max());
write_count = wms.tell();
f.dumpInfo();
if (write_count < best_size) {
best_size = static_cast<uint32_t>(write_count);
best_spec = i;
}
std::cout << "Cur=" << i << " size=" << write_count << " best(" << best_spec << ")=" << best_size << " time=" << clock() - start << std::endl;
#if 0
uint64_t checksum = std::accumulate(&out_data[0], &out_data[write_count], 0UL);
if (old_sum != 0) {
check(old_sum == checksum);
}
old_sum = checksum;
#endif
}
std::cout << "Forward: " << data.size() << "->" << write_count << " rate=" << prettySize(computeRate(data.size() * kIterations, clock() - start)) << "/S" << std::endl;
std::vector<byte> result;
result.resize(data.size());
start = clock();
for (uint32_t i = 0; i < kIterations; ++i) {
WriteMemoryStream wvs(&result[0]);
FilterType reverse_filter(&wvs);
comp.decompress(&ReadMemoryStream(&out_data[0], &out_data[0] + write_count), &reverse_filter, std::numeric_limits<uint64_t>::max());
reverse_filter.flush();
}
uint64_t rate = computeRate(data.size() * kIterations, clock() - start);
std::cout << "Reverse: " << prettySize(rate) << "/S" << std::endl;
// Check tht the shit matches.
check(result.size() == data.size());
for (uint32_t i = 0; i < data.size(); ++i) {
check(result[i] == data[i]);
}
}
int8_t restore_file(FILE * fp, char * remote_name, uint8_t * in_buffer, uint16_t payload_size) {
nwFileHandle nwfp = NULL;
nwBackupCodes open_rc;
int8_t remote_rc = 0; /* Assume success... */
open_rc = openRemoteFile(nwfp, remote_name, 1);
if(!open_rc) { /* If we opened the file ok, read it FROM the remote */
//nwBackupCodes rcv_rc = 0;
nwBackupCodes rcv_rc = TARGET_STILL_HAS_DATA;
int8_t local_file_error = 0;
unsigned long total_size = 0, elapsed_time = 0, prev_elapsed = 0;
startTimer();
while((rcv_rc == TARGET_STILL_HAS_DATA) && !local_file_error) {
uint16_t chars_written, actual_chars_rcvd;
rcv_rc = rcvDataRemote(nwfp, in_buffer, payload_size, &actual_chars_rcvd);
chars_written = fwrite(in_buffer, 1, actual_chars_rcvd, fp);
if(chars_written < actual_chars_rcvd) {
local_file_error = 1;
}
else {
total_size += actual_chars_rcvd;
elapsed_time = getElapsedTime();
if(elapsed_time - prev_elapsed > 1000) {
prev_elapsed = elapsed_time;
fprintf(stderr, "%lu total bytes sent... %lu B/sec\r", total_size, \
computeRate(total_size, elapsed_time));
}
}
}
//fprintf(stderr, "We got here...\n");
/* Cleanup logic scope block */
{
nwBackupCodes close_rc;
if(!local_file_error) {
/* We should close the file even if send_rc errored out! */
close_rc = closeRemoteFile(nwfp);
if(!close_rc && !rcv_rc) {
fprintf(stderr, "File receive okay... %lu total bytes received... %lu B/sec\n", total_size, \
computeRate(total_size, elapsed_time));
remote_rc = 0; /* If we successfully sent the file, we are done. */
}
else {
fprintf(stderr, "Open error code: %d, Rcv error code: %d, Close error code: %d\n", open_rc, rcv_rc, close_rc);
remote_rc = -1; /* Worth retrying transfer. */
}
}
else {
fprintf(stderr, "There was a local file error...\n");
close_rc = closeRemoteFile(nwfp);
remote_rc = -2; /* Do not retry transfer. */
}
}
}
else {
remote_rc = -1;
}
return remote_rc;
}