Getting to the way it's supposed to be!

modules/ufbx/misc/deflate_benchmark/deflate_benchmark.cpp

@@ -0,0 +1,169 @@
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <zlib.h>
+
+#define CPUTIME_IMPLEMENTATION
+#include "../../test/cputime.h"
+#include "../../ufbx.h"
+
+#include <vector>
+#include <assert.h>
+#include <algorithm>
+#include <stdlib.h>
+
+#define UFBX_RETAIN 1
+
+int inflate_memory(const void *src, int srcLen, void *dst, int dstLen) {
+    z_stream strm  = {0};
+    strm.total_in  = strm.avail_in  = srcLen;
+    strm.total_out = strm.avail_out = dstLen;
+    strm.next_in   = (Bytef *) src;
+    strm.next_out  = (Bytef *) dst;
+
+    strm.zalloc = Z_NULL;
+    strm.zfree  = Z_NULL;
+    strm.opaque = Z_NULL;
+
+    int err = -1;
+    int ret = -1;
+
+    err = inflateInit2(&strm, 15);
+    if (err == Z_OK) {
+        err = inflate(&strm, Z_FINISH);
+        if (err == Z_STREAM_END) {
+            ret = strm.total_out;
+        }
+        else {
+             inflateEnd(&strm);
+             return err;
+        }
+    }
+    else {
+        inflateEnd(&strm);
+        return err;
+    }
+
+    inflateEnd(&strm);
+    return ret;
+}
+
+std::vector<char> read_file(const char *path)
+{
+	FILE *f = fopen(path, "rb");
+	fseek(f, 0, SEEK_END);
+	std::vector<char> data;
+	data.resize(ftell(f));
+	fseek(f, 0, SEEK_SET);
+	fread(data.data(), 1, data.size(), f);
+	fclose(f);
+	return data;
+}
+
+struct deflate_stream
+{
+    const void *data;
+    size_t compressed_size;
+    size_t decompressed_size;
+
+    uint64_t zlib_time = UINT64_MAX;
+    uint64_t ufbx_time = UINT64_MAX;
+};
+
+int main(int argc, char **argv)
+{
+	std::vector<char> data = read_file(argv[1]);
+	std::vector<deflate_stream> streams;
+	std::vector<char> dst_buf;
+
+    cputime_begin_init();
+
+    size_t max_decompressed_size = 0;
+
+    for (size_t offset = 0; offset < data.size(); ) {
+        deflate_stream stream;
+        stream.compressed_size = *(uint32_t*)(data.data() + offset + 0);
+        stream.decompressed_size = *(uint32_t*)(data.data() + offset + 4);
+        stream.data = data.data() + offset + 8;
+        offset += 8 + stream.compressed_size;
+        if (stream.decompressed_size > max_decompressed_size) {
+            max_decompressed_size = stream.decompressed_size;
+        }
+        streams.push_back(stream);
+    }
+
+    if (argc > 2) {
+        deflate_stream single = streams[atoi(argv[2])];
+        streams.clear();
+        streams.push_back(single);
+    }
+
+    size_t runs = 3;
+    if (argc > 3) {
+        runs = (size_t)atoi(argv[3]);
+    }
+
+    dst_buf.resize(max_decompressed_size);
+
+    for (size_t i = 0; i < runs; i++) {
+		for (deflate_stream &stream : streams) {
+			uint64_t begin = cputime_cpu_tick();
+
+			int ret = inflate_memory(stream.data, (int)stream.compressed_size,
+				dst_buf.data(), (int)stream.decompressed_size);
+			assert(ret == stream.decompressed_size);
+
+			uint64_t end = cputime_cpu_tick();
+
+            if (argc > 20) {
+                fwrite(dst_buf.data(), 1, stream.decompressed_size, stdout);
+            }
+
+			stream.zlib_time = std::min(stream.zlib_time, end - begin);
+		}
+
+#if UFBX_RETAIN
+		ufbx_inflate_retain retain;
+		retain.initialized = false;
+#endif
+
+		for (deflate_stream &stream : streams) {
+			uint64_t begin = cputime_cpu_tick();
+
+#if !UFBX_RETAIN
+			ufbx_inflate_retain retain;
+			retain.initialized = false;
+#endif
+
+			ufbx_inflate_input input = { };
+			input.data_size = input.total_size = stream.compressed_size;
+			input.data = stream.data;
+			ptrdiff_t ret = ufbx_inflate(dst_buf.data(), stream.decompressed_size, &input, &retain);
+			assert(ret == stream.decompressed_size);
+
+            if (argc > 20) {
+                fwrite(dst_buf.data(), 1, stream.decompressed_size, stdout);
+            }
+
+			uint64_t end = cputime_cpu_tick();
+			stream.ufbx_time = std::min(stream.ufbx_time, end - begin);
+		}
+    }
+
+    cputime_end_init();
+
+    uint32_t index = 0;
+    for (deflate_stream &stream : streams) {
+        double ufbx_sec = cputime_cpu_delta_to_sec(NULL, stream.ufbx_time);
+        double zlib_sec = cputime_cpu_delta_to_sec(NULL, stream.zlib_time);
+        double ufbx_cbp = (double)stream.ufbx_time / (double)stream.decompressed_size;
+        double zlib_cbp = (double)stream.zlib_time / (double)stream.decompressed_size;
+
+        printf("[%6.2f] %3u: %10zu -> %10zu bytes: %8.4fms (%6.2fcy/b) vs %8.4fms (%6.2fcy/b)\n",
+            ufbx_sec / zlib_sec * 100.0, index,
+            stream.compressed_size, stream.decompressed_size,
+            ufbx_sec*1e3, ufbx_cbp, zlib_sec*1e3, zlib_cbp);
+        index++;
+    }
+
+    return 0;
+}

modules/ufbx/misc/deflate_benchmark/gather_deflate.py

@@ -0,0 +1,21 @@
+import argparse
+import os
+import subprocess
+
+parser = argparse.ArgumentParser(description="Gather DEFLATE compressed streams from .fbx files")
+parser.add_argument("--exe", help="Executable path for per-file gathering, see `gather_deflate_main.cpp`")
+parser.add_argument("-o", help="Output file")
+parser.add_argument("--root", help="Root path to look for .fbx files")
+argv = parser.parse_args()
+
+data = bytearray()
+
+for root,_,files in os.walk(argv.root):
+    for file in files:
+        if not file.endswith(".fbx"): continue
+        path = os.path.join(root, file)
+        print(path)
+        data += subprocess.check_output([argv.exe, path])
+
+with open(argv.o, "wb") as f:
+    f.write(data)

modules/ufbx/misc/deflate_benchmark/gather_deflate_main.cpp

@@ -0,0 +1,61 @@
+#define _CRT_SECURE_NO_WARNINGS
+
+#include "../../test/domfuzz/fbxdom.h"
+#include <vector>
+#include <string>
+#include <stdio.h>
+
+#ifdef _WIN32
+	#include <fcntl.h>
+	#include <io.h>
+#endif
+
+std::vector<char> read_file(const char *path)
+{
+	FILE *f = fopen(path, "rb");
+	fseek(f, 0, SEEK_END);
+	std::vector<char> data;
+	data.resize(ftell(f));
+	fseek(f, 0, SEEK_SET);
+	fread(data.data(), 1, data.size(), f);
+	fclose(f);
+	return data;
+}
+
+void dump_deflate_arrays(fbxdom::node_ptr node)
+{
+	for (fbxdom::value &value : node->values) {
+		if (value.data_array.encoding == 1) {
+			uint32_t decompressed_size = 0;
+			switch (value.type) {
+			case 'c': case 'b': decompressed_size = value.data_array.length * 1; break;
+			case 'i': case 'f': decompressed_size = value.data_array.length * 4; break;
+			case 'l': case 'd': decompressed_size = value.data_array.length * 8; break;
+			}
+
+			fwrite(&value.data_array.compressed_length, 4, 1, stdout);
+			fwrite(&decompressed_size, 4, 1, stdout);
+
+			fwrite(value.data.data(), 1, value.data.size(), stdout);
+		}
+	}
+
+	for (fbxdom::node_ptr &child : node->children) {
+		dump_deflate_arrays(child);
+	}
+}
+
+int main(int argc, char **argv)
+{
+	std::vector<char> data = read_file(argv[1]);
+	fbxdom::node_ptr root = fbxdom::parse(data.data(), data.size());
+	if (!root) return 0;
+
+#ifdef _WIN32
+	_setmode(_fileno(stdout), O_BINARY);
+#endif
+
+	dump_deflate_arrays(root);
+
+	return 0;
+}