static void
benchmark_codec (SquashCodec* codec, void* data) {
struct BenchmarkContext* context = (struct BenchmarkContext*) data;
SquashOptions* opts;
int level = 0;
char level_s[4];
bool have_results = false;
umask (0100);
fprintf (stdout, " %s:%s\n",
squash_plugin_get_name (squash_codec_get_plugin (codec)),
squash_codec_get_name (codec));
opts = squash_options_new (codec, NULL);
if (opts != NULL) {
squash_object_ref_sink (opts);
for ( level = 0 ; level <= 999 ; level++ ) {
snprintf (level_s, 4, "%d", level);
if (squash_options_parse_option (opts, "level", level_s) == SQUASH_OK) {
if (benchmark_codec_with_options (context, codec, opts)) {
have_results = true;
}
}
}
squash_object_unref (opts);
}
if (!have_results) {
benchmark_codec_with_options (context, codec, NULL);
}
}
static bool
benchmark_codec_with_options (struct BenchmarkContext* context, SquashCodec* codec, SquashOptions* opts) {
SquashBenchmarkResult result = { 0, 0.0, 0.0, 0.0, 0.0 };
bool success = false;
SquashStatus res = SQUASH_OK;
const int level = squash_options_get_int (opts, codec, "level");
#if !defined(SQUASH_BENCHMARK_NO_FORK)
char fifo_name[] = ".squash-benchmark-fifo-XXXXXX";
assert (mkfifo (mktemp (fifo_name), 0600) == 0);
if (fork () == 0) {
int out_descriptor = open (fifo_name, O_WRONLY);
#else
int descriptors[2];
assert (pipe (descriptors) == 0);
int out_descriptor = descriptors[1];
#endif
FILE* compressed = squash_tmpfile ();
FILE* decompressed = squash_tmpfile ();
SquashTimer* timer = squash_timer_new ();
int iterations = 0;
if (level < 0) {
fputs (" compressing: ", stdout);
} else {
fprintf (stdout, " level %d: ", level);
}
if (fseek (context->input, 0, SEEK_SET) != 0) {
perror ("Unable to seek to beginning of input file");
exit (-1);
}
for ( iterations = 0 ; squash_timer_get_elapsed_cpu (timer) < min_exec_time ; iterations++ ) {
fseek (context->input, 0, SEEK_SET);
fseek (compressed, 0, SEEK_SET);
rewind (compressed);
squash_timer_start (timer);
res = squash_splice_with_options (codec, SQUASH_STREAM_COMPRESS, compressed, context->input, 0, opts);
squash_timer_stop (timer);
rewind (context->input);
if (res != SQUASH_OK) {
fprintf (stderr, "ERROR: %s (%d) squash_splice_with_options (%s, compress, %p, %p, 0, %p)\n", squash_status_to_string (res), res, squash_codec_get_name (codec), compressed, context->input, opts);
break;
}
}
if (res == SQUASH_OK) {
result.compressed_size = ftell (compressed);
result.compress_cpu = squash_timer_get_elapsed_cpu (timer) / iterations;
result.compress_wall = squash_timer_get_elapsed_wall (timer) / iterations;
squash_timer_reset (timer);
if (result.compressed_size == 0) {
fprintf (stdout, "failed (0 byte output, %s [%d]).\n", squash_status_to_string (res), res);
} else {
fprintf (stdout, "compressed (%.6fs CPU, %.6fs wall, %ld bytes)... ",
result.compress_cpu,
result.compress_wall,
result.compressed_size);
for ( iterations = 0 ; squash_timer_get_elapsed_cpu (timer) < min_exec_time ; iterations++ ) {
fseek (compressed, 0, SEEK_SET);
fseek (decompressed, 0, SEEK_SET);
squash_timer_start (timer);
res = squash_splice_with_options (codec, SQUASH_STREAM_DECOMPRESS, decompressed, compressed, 0, opts);
squash_timer_stop (timer);
rewind (compressed);
if (res != SQUASH_OK) {
break;
}
}
if (res != SQUASH_OK) {
fprintf (stderr, "Failed (%s [%d]).\n", squash_status_to_string (res), res);
} else {
result.decompress_cpu = squash_timer_get_elapsed_cpu (timer) / iterations;
result.decompress_wall = squash_timer_get_elapsed_wall (timer) / iterations;
squash_timer_reset (timer);
if (ftell (decompressed) != context->input_size) {
/* Should never happen. */
fprintf (stderr, "Failed (size mismatch; expected %ld, got %ld.\n", context->input_size, ftell (decompressed));
} else {
fprintf (stdout, "decompressed (%.6fs CPU, %.6fs wall).\n",
result.decompress_cpu,
result.decompress_wall);
write (out_descriptor, &result, sizeof (SquashBenchmarkResult));
}
}
}
}
squash_timer_free (timer);
fclose (compressed);
fclose (decompressed);
close (out_descriptor);
#if !defined(SQUASH_BENCHMARK_NO_FORK)
exit (0);
} else {
int in_descriptor = open (fifo_name, O_RDONLY);
#else
int in_descriptor = descriptors[0];
#endif
size_t bytes_read = read (in_descriptor, &result, sizeof (SquashBenchmarkResult));
wait (NULL);
if (bytes_read == sizeof (SquashBenchmarkResult)) {
if (context->csv != NULL) {
if (level >= 0) {
fprintf (context->csv, "%s,%s,%s,%d,%ld,%f,%f,%f,%f\r\n",
context->input_name,
squash_plugin_get_name (squash_codec_get_plugin (codec)),
squash_codec_get_name (codec),
level,
result.compressed_size,
result.compress_cpu,
result.compress_wall,
result.decompress_cpu,
result.decompress_wall);
} else {
fprintf (context->csv, "%s,%s,%s,,%ld,%f,%f,%f,%f\r\n",
context->input_name,
squash_plugin_get_name (squash_codec_get_plugin (codec)),
squash_codec_get_name (codec),
result.compressed_size,
result.compress_cpu,
result.compress_wall,
result.decompress_cpu,
result.decompress_wall);
}
}
success = true;
}
close (in_descriptor);
#if !defined(SQUASH_BENCHMARK_NO_FORK)
unlink (fifo_name);
}
#endif
return success;
}
static void
list_plugins_foreach_cb (SquashPlugin* plugin, void* data) {
fputs (squash_plugin_get_name (plugin), stdout);
fputc ('\n', stdout);
}
