sse_hash3.c

#include <sys/types.h>
#include <stdint.h>
#include <string.h>
#include <x86intrin.h>

#include "sse_hash3.h"

static const __m128i k1 = { 0xcc9e2d51db873593, 0xcc9e2d51db873593 };

static const __m128i s1 = { 0xc05bbd6b47c57574, 0xf83c1e9e4a934534 };
static const __m128i s2 = { 0xa224e4507e645d91, 0xe7a9131a4b842813 };
static const __m128i s3 = { 0x58f082e3580f347e, 0xceb5795349196aff };
static const __m128i s4 = { 0xb549200b5168588f, 0xfd5c07200540ada5 };

static inline __m128i
mix128(const __m128i h)
{
	__m128i a, b;

	a = _mm_xor_si128(h, k1);
	b = _mm_alignr_epi8(a, a, 12);
	a = _mm_mul_epu32(a, b);

	return a;
}

static inline __m128i
round128(const __m128i h, const __m128i x)
{
	__m128i a;

	a = _mm_xor_si128(h, x);
	a = mix128(a);

	return a;
}

static inline __m128i
combine128(const __m128i h, const __m128i x)
{
	__m128i a, m;

	m = _mm_set_epi32(3, 3, 3, 3);
	a = _mm_mullo_epi32(h, m);
	a = _mm_add_epi64(a, x);

	return a;
}

static inline __m128i
fmix128(const __m128i h)
{
	__m128i a;

	a = _mm_xor_si128(h, _mm_srli_epi32(h, 16));
	a = _mm_mullo_epi32(a, k1);
	a = _mm_xor_si128(a, _mm_srli_epi32(a, 16));

	return a;
}

void
sse_hash3_start_seed(sse_hash3_state_t * const state,
    const void * const seed)
{
	__m128i s;

	s = _mm_loadu_si128(seed);
	state->x1 = _mm_xor_si128(s1, s);
	state->x2 = _mm_xor_si128(s2, s);
	state->x3 = _mm_xor_si128(s3, s);
	state->x4 = _mm_xor_si128(s4, s);
	state->block_size = sizeof(state->buf);
	state->count = 0;
	state->total_len = 0;
}

void
sse_hash3_start(sse_hash3_state_t * const state)
{
	uint64_t seed[2] = { 0, 0 };

	sse_hash3_start_seed(state, seed);
}

void
sse_hash3_update(sse_hash3_state_t * const state, const void * const data,
    const size_t len)
{
	__m128i *v;
	__m128i x1, x2, x3, x4;
	const unsigned char *curr = data;
	size_t llen;
	uint32_t left;

	if (data == NULL || len == 0)
		return;

	if (state->count + len < state->block_size) {
		memcpy(state->buf.chars + state->count, data, len);
		state->count += len;
		return;
	}

	llen = len;

	if (state->count > 0) {
		left = state->block_size - state->count;
		memcpy(state->buf.chars + state->count, data, left);
		llen -= left;
		curr += left;
	}

	x1 = state->x1;
	x2 = state->x2;
	x3 = state->x3;
	x4 = state->x4;

	if (state->count > 0) {
		v = state->buf.ints;

		x1 = round128(x1, v[0]);
		x2 = round128(x2, v[1]);
		x3 = round128(x3, v[2]);
		x4 = round128(x4, v[3]);

		state->count = 0;
	}

	while (llen >= state->block_size) {
		v = (__m128i_u *)curr;

		x1 = round128(x1, _mm_loadu_si128(&v[0]));
		x2 = round128(x2, _mm_loadu_si128(&v[1]));
		x3 = round128(x3, _mm_loadu_si128(&v[2]));
		x4 = round128(x4, _mm_loadu_si128(&v[3]));

		curr += state->block_size;
		llen -= state->block_size;
	}

	state->x1 = x1;
	state->x2 = x2;
	state->x3 = x3;
	state->x4 = x4;

	if (llen > 0) {
		memcpy(state->buf.chars, curr, llen);
		state->count = llen;
	}
}

static const unsigned char padding[256] = { 0x80 };

void
sse_hash3_end(sse_hash3_state_t * const state, sse_hash3_t * const hash)
{
	__m128i h, x1, x2, x3, x4;
	uint64_t total_len;
	uint32_t len, i;

	total_len = state->total_len;
	len = (state->count < 56) ? 56 - state->count : 120 - state->count;
	sse_hash3_update(state, padding, len);
	sse_hash3_update(state, &total_len, 8);

	x1 = state->x1;
	x2 = state->x2;
	x3 = state->x3;
	x4 = state->x4;

	for (i = 0; i < 4; i++) {
		x1 = mix128(x1);
		x2 = mix128(x2);
		x3 = mix128(x3);
		x4 = mix128(x4);
	}

	x1 = combine128(x1, x2);
	x3 = combine128(x3, x4);
	h = combine128(x1, x3);
	h = fmix128(h);

	_mm_storeu_si128((__m128i_u *)hash, h);
}

void
sse_hash3_seed(const void * const data, const size_t len,
    const void * const seed, sse_hash3_t * const hash)
{
	sse_hash3_state_t sse_hash2;

	sse_hash3_start_seed(&sse_hash2, seed);
	sse_hash3_update(&sse_hash2, data, len);
	sse_hash3_end(&sse_hash2, hash);
}

void
sse_hash3(const void * const data, const size_t len,
    sse_hash3_t * const hash)
{
	uint64_t seed[2] = { 0, 0 };

	sse_hash3_seed(data, len, seed, hash);
}