Implement SSE2 Tiger hashing.

src/tiger.cpp

@@ -0,0 +1,92 @@
+/* Copyright 2015, Michele Santullo
+ * This file is part of "dindexer".
+ *
+ * "dindexer" is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * "dindexer" is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with "dindexer".  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tiger.hpp"
+#include <fstream>
+#include <cstdint>
+#include <memory>
+#include <cassert>
+#include <algorithm>
+#include <sstream>
+
+#if defined(__SSE2__)
+extern "C" void tiger_sse2_chunk ( const char* parStr1, const char* parStr2, uint64_t parLength, uint64_t parRes1[3], uint64_t parRes2[3] );
+extern "C" void tiger_sse2_last_chunk ( const char* parStr1, const char* parStr2, uint64_t parLength, uint64_t parRealLength, uint64_t parRes1[3], uint64_t parRes2[3], char pad );
+
+#else
+#	error "Not implemented without SSE2"
+#endif
+
+namespace din {
+	namespace {
+		const uint32_t g_buff_size = 1024 * 8;
+		const char g_tiger_padding = 0x80; //0x01 for V1
+
+		uint64_t swap_long (uint64_t parNum) {
+			parNum = (parNum & 0x00000000FFFFFFFF) << 32 | (parNum & 0xFFFFFFFF00000000) >> 32;
+			parNum = (parNum & 0x0000FFFF0000FFFF) << 16 | (parNum & 0xFFFF0000FFFF0000) >> 16;
+			parNum = (parNum & 0x00FF00FF00FF00FF) << 8  | (parNum & 0xFF00FF00FF00FF00) >> 8;
+			return parNum;
+		}
+	} //unnamed namespace
+
+	void tiger_init_hash (TigerHash& parHash) {
+		parHash.part_a = 0x0123456789ABCDEFULL;
+		parHash.part_b = 0xFEDCBA9876543210ULL;
+		parHash.part_c = 0xF096A5B4C3B2E187ULL;
+	}
+
+	void tiger_file (const std::string& parPath, TigerHash& parHashFile, TigerHash& parHashDir) {
+		tiger_init_hash(parHashFile);
+
+		std::ifstream src(parPath, std::ios::binary);
+		src.seekg(0, std::ios_base::end);
+		const auto file_size = src.tellg();
+		src.seekg(0, std::ios_base::beg);
+
+		const uint32_t buffsize = static_cast<uint32_t>(std::min<decltype(file_size)>(file_size, g_buff_size));
+		std::unique_ptr<char[]> buff(new char[63 + buffsize]);
+		char* const buff_ptr = reinterpret_cast<char*>(reinterpret_cast<std::intptr_t>(buff.get() + 63) & (-64));
+		assert(buff_ptr >= buff.get() and buff_ptr + buffsize <= buff.get() + 63 + buffsize);
+
+		auto remaining = file_size;
+		while (remaining > buffsize) {
+			assert(buffsize >= sizeof(uint64_t) * 3);
+			assert(buffsize == (buffsize & -64));
+			remaining -= buffsize;
+			src.read(buff_ptr, buffsize);
+			tiger_sse2_chunk(buff_ptr, buff_ptr, buffsize, parHashFile.data, parHashDir.data);
+		}
+
+		{
+			assert(remaining <= buffsize);
+			src.read(buff_ptr, remaining);
+			const auto aligned_size = remaining & -64;
+			if (aligned_size) {
+				tiger_sse2_chunk(buff_ptr, buff_ptr, aligned_size, parHashFile.data, parHashDir.data);
+			}
+
+			tiger_sse2_last_chunk(buff_ptr + aligned_size, buff_ptr + aligned_size, remaining - aligned_size, file_size, parHashFile.data, parHashDir.data, g_tiger_padding);
+		}
+	}
+
+	std::string tiger_to_string (const TigerHash& parHash) {
+		std::ostringstream oss;
+		oss << std::hex << swap_long(parHash.part_a) << swap_long(parHash.part_b) << swap_long(parHash.part_c);
+		return oss.str();
+	}
+} //namespace din