Split out SSE2 and SSSE3 versions

Author: randombit

Makefile

@@ -1,41 +1,57 @@
 
-CC=g++
-WARNINGS= -Wall -Wextra
-OPTFLAGS=-O2 -march=native
+CXX=g++
+WARNINGS=-Wall -Wextra
+OPTFLAGS=-std=c++11 -O2 -fPIC
 DEBUGFLAGS=-g
 
-CFLAGS=$(OPTFLAGS) $(DEBUGFLAGS) $(WARNINGS)
+CXXFLAGS=$(OPTFLAGS) $(DEBUGFLAGS) $(WARNINGS)
 
 PROGS = benchmark zfec test_recovery gen_test_vec
 
-all: fecpp.so $(PROGS)
+all: fecpp.so pyfecpp.so $(PROGS)
 
-libfecpp.a: fecpp.o
-	ar crs $@ $<
+PYTHON_PKGCONFIG=python2
+
+OBJ=fecpp.o cpuid.o fecpp_sse2.o fecpp_ssse3.o
+
+libfecpp.a: $(OBJ)
+	ar crs $@ $(OBJ)
 
 fecpp.o: fecpp.cpp fecpp.h
-	$(CC) $(CFLAGS) -I. -c $< -o $@
+	$(CXX) $(CXXFLAGS) -I. -c $< -o $@
+
+cpuid.o: cpuid.cpp fecpp.h
+	$(CXX) $(CXXFLAGS) -I. -c $< -o $@
+
+fecpp_sse2.o: fecpp_sse2.cpp fecpp.h
+	$(CXX) $(CXXFLAGS) -msse2 -I. -c $< -o $@
+
+fecpp_ssse3.o: fecpp_ssse3.cpp fecpp.h
+	$(CXX) $(CXXFLAGS) -mssse3 -I. -c $< -o $@
 
 test/%.o: test/%.cpp fecpp.h
-	$(CC) $(CFLAGS) -I. -c $< -o $@
+	$(CXX) $(CXXFLAGS) -I. -c $< -o $@
 
 zfec: test/zfec.o libfecpp.a
-	$(CC) $(CFLAGS) $<  -L. -lfecpp -o $@
+	$(CXX) $(CXXFLAGS) $<  -L. -lfecpp -o $@
 
 benchmark: test/benchmark.o libfecpp.a
-	$(CC) $(CFLAGS) $<  -L. -lfecpp -o $@
+	$(CXX) $(CXXFLAGS) $<  -L. -lfecpp -o $@
 
 test_fec: test/test_fec.o libfecpp.a
-	$(CC) $(CFLAGS) $<  -L. -lfecpp -o $@
+	$(CXX) $(CXXFLAGS) $<  -L. -lfecpp -o $@
 
 test_recovery: test/test_recovery.o libfecpp.a
-	$(CC) $(CFLAGS) $< -L. -lfecpp -o $@
+	$(CXX) $(CXXFLAGS) $< -L. -lfecpp -o $@
 
 gen_test_vec: test/gen_test_vec.o libfecpp.a
-	$(CC) $(CFLAGS) $< -L. -lfecpp -o $@
+	$(CXX) $(CXXFLAGS) $< -L. -lfecpp -o $@
+
+fecpp.so: $(OBJ) fecpp.h
+	$(CXX) -shared -fPIC $(CXXFLAGS) $(OBJ) -o fecpp.so
 
-fecpp.so: fecpp.cpp fecpp_python.cpp fecpp.h
-	$(CC) -shared -fPIC $(CFLAGS) `pkg-config --cflags python` fecpp.cpp fecpp_python.cpp `pkg-config --libs python` -lboost_python -o fecpp.so
+pyfecpp.so: fecpp_python.cpp fecpp.h fecpp.so
+	$(CXX) -shared -fPIC $(CXXFLAGS) `pkg-config --cflags $(PYTHON_PKGCONFIG)` fecpp_python.cpp `pkg-config --libs $(PYTHON_PKGCONFIG)` -lboost_python fecpp.so -o pyfecpp.so
 
 clean:
 	rm -f fecpp.so *.a *.o test/*.o

cpuid.cpp

@@ -0,0 +1,10 @@
+
+#include "fecpp.h"
+
+namespace fecpp {
+
+bool has_sse2() { return true; }
+
+bool has_ssse3() { return true; }
+
+}

fecpp.cpp

@@ -2,13 +2,13 @@
  * Forward error correction based on Vandermonde matrices
  *
  * (C) 1997-1998 Luigi Rizzo ([email protected])
- * (C) 2009 Jack Lloyd (lloyd@randombit.net)
+ * (C) 2009 Jack Lloyd (jack@randombit.net)
  *
  * Distributed under the terms given in license.txt
  */
 
-#ifndef FECPP_H__
-#define FECPP_H__
+#ifndef FECPP_H_
+#define FECPP_H_
 
 #include <map>
 #include <vector>
@@ -22,6 +22,10 @@ using std::size_t;
 
 using byte = std::uint8_t;
 
+#if defined(__i386__) || defined(__x86_64__)
+  #define FECPP_IS_X86
+#endif
+
 /**
 * Forward error correction code
 */
@@ -63,6 +67,19 @@ class fec_code
       std::vector<uint8_t> enc_matrix;
    };
 
+#if defined(FECPP_IS_X86)
+
+/**
+* CPU runtime detection
+*/
+bool has_sse2();
+bool has_ssse3();
+
+size_t addmul_sse2(uint8_t z[], const uint8_t x[], uint8_t y, size_t size);
+size_t addmul_ssse3(uint8_t z[], const uint8_t x[], uint8_t y, size_t size);
+
+#endif
+
 }
 
 #endif

fecpp.h

@@ -0,0 +1,100 @@
+/*
+ * (C) 2009-2010 Jack Lloyd ([email protected])
+ *
+ * Distributed under the terms given in license.txt (Simplified BSD)
+ */
+
+#include "fecpp.h"
+#include <emmintrin.h>
+
+namespace fecpp {
+
+size_t addmul_sse2(uint8_t z[], const uint8_t x[], uint8_t y, size_t size)
+   {
+   const __m128i polynomial = _mm_set1_epi8(0x1D);
+
+   const size_t y_bits = 32 - __builtin_clz(y);
+
+   // unrolled out to cache line size
+   while(size >= 64)
+      {
+      __m128i x_1 = _mm_loadu_si128((const __m128i*)(x));
+      __m128i x_2 = _mm_loadu_si128((const __m128i*)(x + 16));
+      __m128i x_3 = _mm_loadu_si128((const __m128i*)(x + 32));
+      __m128i x_4 = _mm_loadu_si128((const __m128i*)(x + 48));
+
+      __m128i z_1 = _mm_load_si128((const __m128i*)(z));
+      __m128i z_2 = _mm_load_si128((const __m128i*)(z + 16));
+      __m128i z_3 = _mm_load_si128((const __m128i*)(z + 32));
+      __m128i z_4 = _mm_load_si128((const __m128i*)(z + 48));
+
+      // prefetch next two x and z blocks
+      _mm_prefetch(x + 64, _MM_HINT_T0);
+      _mm_prefetch(z + 64, _MM_HINT_T0);
+      _mm_prefetch(x + 128, _MM_HINT_T1);
+      _mm_prefetch(z + 128, _MM_HINT_T1);
+
+      if(y & 0x01)
+         {
+         z_1 = _mm_xor_si128(z_1, x_1);
+         z_2 = _mm_xor_si128(z_2, x_2);
+         z_3 = _mm_xor_si128(z_3, x_3);
+         z_4 = _mm_xor_si128(z_4, x_4);
+         }
+
+      for(size_t j = 1; j != y_bits; ++j)
+         {
+         /*
+         * Each byte of each mask is either 0 or the polynomial 0x1D,
+         * depending on if the high bit of x_i is set or not.
+         */
+
+         __m128i mask_1 = _mm_setzero_si128();
+         __m128i mask_2 = _mm_setzero_si128();
+         __m128i mask_3 = _mm_setzero_si128();
+         __m128i mask_4 = _mm_setzero_si128();
+
+         // flip operation?
+         mask_1 = _mm_cmpgt_epi8(mask_1, x_1);
+         mask_2 = _mm_cmpgt_epi8(mask_2, x_2);
+         mask_3 = _mm_cmpgt_epi8(mask_3, x_3);
+         mask_4 = _mm_cmpgt_epi8(mask_4, x_4);
+
+         x_1 = _mm_add_epi8(x_1, x_1);
+         x_2 = _mm_add_epi8(x_2, x_2);
+         x_3 = _mm_add_epi8(x_3, x_3);
+         x_4 = _mm_add_epi8(x_4, x_4);
+
+         mask_1 = _mm_and_si128(mask_1, polynomial);
+         mask_2 = _mm_and_si128(mask_2, polynomial);
+         mask_3 = _mm_and_si128(mask_3, polynomial);
+         mask_4 = _mm_and_si128(mask_4, polynomial);
+
+         x_1 = _mm_xor_si128(x_1, mask_1);
+         x_2 = _mm_xor_si128(x_2, mask_2);
+         x_3 = _mm_xor_si128(x_3, mask_3);
+         x_4 = _mm_xor_si128(x_4, mask_4);
+
+         if((y >> j) & 1)
+            {
+            z_1 = _mm_xor_si128(z_1, x_1);
+            z_2 = _mm_xor_si128(z_2, x_2);
+            z_3 = _mm_xor_si128(z_3, x_3);
+            z_4 = _mm_xor_si128(z_4, x_4);
+            }
+         }
+
+      _mm_store_si128((__m128i*)(z     ), z_1);
+      _mm_store_si128((__m128i*)(z + 16), z_2);
+      _mm_store_si128((__m128i*)(z + 32), z_3);
+      _mm_store_si128((__m128i*)(z + 48), z_4);
+
+      x += 64;
+      z += 64;
+      size -= 64;
+      }
+
+   return size;
+   }
+
+}