text: /**
   * @file
   *
   * @author jeffrey.daily@gmail.com
   *
   * Copyright (c) 2015 Battelle Memorial Institute.
   */
  #include "config.h"
  
  #include <stdint.h>
  #include <stdlib.h>
  #include <string.h>
  
  #if defined(_MSC_VER)
  #include <intrin.h>
  #else
  #include <emmintrin.h>
  #endif
  
  #include "parasail.h"
  #include "parasail/memory.h"
  #include "parasail/internal_sse.h"
  
  
  static inline int16_t _mm_hmax_epi16_rpl(__m128i a) {
      a = _mm_max_epi16(a, _mm_srli_si128(a, 8));
      a = _mm_max_epi16(a, _mm_srli_si128(a, 4));
      a = _mm_max_epi16(a, _mm_srli_si128(a, 2));
      return _mm_extract_epi16(a, 0);
  }
  
  
  #ifdef PARASAIL_TABLE
  static inline void arr_store_si128(
          int *array,
          __m128i vH,
          int32_t t,
          int32_t seglen,
          int32_t d,
          int32_t dlen)
  {
      array[1LL*(0*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 0);
      array[1LL*(1*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 1);
      array[1LL*(2*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 2);
      array[1LL*(3*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 3);
      array[1LL*(4*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 4);
      array[1LL*(5*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 5);
      array[1LL*(6*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 6);
      array[1LL*(7*seglen+t)*dlen + d] = (int16_t)_mm_extract_epi16(vH, 7);
  }
  #endif
  
  #ifdef PARASAIL_ROWCOL
  static inline void arr_store_col(
          int *col,
          __m128i vH,
          int32_t t,
          int32_t seglen)
  {
      col[0*seglen+t] = (int16_t)_mm_extract_epi16(vH, 0);
      col[1*seglen+t] = (int16_t)_mm_extract_epi16(vH, 1);
      col[2*seglen+t] = (int16_t)_mm_extract_epi16(vH, 2);
      col[3*seglen+t] = (int16_t)_mm_extract_epi16(vH, 3);
      col[4*seglen+t] = (int16_t)_mm_extract_epi16(vH, 4);
      col[5*seglen+t] = (int16_t)_mm_extract_epi16(vH, 5);
      col[6*seglen+t] = (int16_t)_mm_extract_epi16(vH, 6);
      col[7*seglen+t] = (int16_t)_mm_extract_epi16(vH, 7);
  }
  #endif
  
  #ifdef PARASAIL_TABLE
  #define FNAME parasail_sw_table_scan_sse2_128_16
  #define PNAME parasail_sw_table_scan_profile_sse2_128_16
  #else
  #ifdef PARASAIL_ROWCOL
  #define FNAME parasail_sw_rowcol_scan_sse2_128_16
  #define PNAME parasail_sw_rowcol_scan_profile_sse2_128_16
  #else
  #define FNAME parasail_sw_scan_sse2_128_16
  #define PNAME parasail_sw_scan_profile_sse2_128_16
  #endif
  #endif
  
  parasail_result_t* FNAME(
          const char * const restrict s1, const int s1Len,
          const char * const restrict s2, const int s2Len,
          const int open, const int gap, const parasail_matrix_t *matrix)
  {
      /* declare local variables */
      parasail_profile_t *profile = NULL;
      parasail_result_t *result = NULL;
  
      /* validate inputs */
      PARASAIL_CHECK_NULL(s2);
      PARASAIL_CHECK_GT0(s2Len);
      PARASAIL_CHECK_GE0(open);
      PARASAIL_CHECK_GE0(gap);
      PARASAIL_CHECK_NULL(matrix);
      if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
          PARASAIL_CHECK_NULL(s1);
          PARASAIL_CHECK_GT0(s1Len);
      }
  
      /* initialize local variables */
      profile = parasail_profile_create_sse_128_16(s1, s1Len, matrix);
      if (!profile) return NULL;
      result = PNAME(profile, s2, s2Len, open, gap);
  
      parasail_profile_free(profile);
  
      return result;
  }
  
  parasail_result_t* PNAME(
          const parasail_profile_t * const restrict profile,
          const char * const restrict s2, const int s2Len,
          const int open, const int gap)
  {
      /* declare local variables */
      int32_t i = 0;
      int32_t j = 0;
      int32_t end_query = 0;
      int32_t end_ref = 0;
      int32_t s1Len = 0;
      const parasail_matrix_t *matrix = NULL;
      int32_t segWidth = 0;
      int32_t segLen = 0;
  #ifdef PARASAIL_ROWCOL
      int32_t offset = 0;
      int32_t position = 0;
  #endif
      __m128i* restrict pvP = NULL;
      __m128i* restrict pvE = NULL;
      __m128i* restrict pvHt = NULL;
      __m128i* restrict pvH = NULL;
      __m128i* restrict pvHMax = NULL;
      __m128i* restrict pvGapper = NULL;
      __m128i vGapO;
      __m128i vGapE;
      int16_t NEG_LIMIT = 0;
      int16_t POS_LIMIT = 0;
      __m128i vZero;
      int16_t score = 0;
      __m128i vNegLimit;
      __m128i vPosLimit;
      __m128i vSaturationCheckMin;
      __m128i vSaturationCheckMax;
      __m128i vMaxH;
      __m128i vMaxHUnit;
      __m128i vNegInfFront;
      __m128i vSegLenXgap;
      parasail_result_t *result = NULL;
  
      /* validate inputs */
      PARASAIL_CHECK_NULL(profile);
      PARASAIL_CHECK_NULL(profile->profile16.score);
      PARASAIL_CHECK_NULL(profile->matrix);
      PARASAIL_CHECK_GT0(profile->s1Len);
      PARASAIL_CHECK_NULL(s2);
      PARASAIL_CHECK_GT0(s2Len);
      PARASAIL_CHECK_GE0(open);
      PARASAIL_CHECK_GE0(gap);
  
      /* initialize stack variables */
      i = 0;
      j = 0;
      end_query = 0;
      end_ref = 0;
      s1Len = profile->s1Len;
      matrix = profile->matrix;
      segWidth = 8; /* number of values in vector unit */
      segLen = (s1Len + segWidth - 1) / segWidth;
  #ifdef PARASAIL_ROWCOL
      offset = (s1Len - 1) % segLen;
      position = (segWidth - 1) - (s1Len - 1) / segLen;
  #endif
      pvP = (__m128i*)profile->profile16.score;
      vGapO = _mm_set1_epi16(open);
      vGapE = _mm_set1_epi16(gap);
      NEG_LIMIT = (-open < matrix->min ? INT16_MIN + open : INT16_MIN - matrix->min) + 1;
      POS_LIMIT = INT16_MAX - matrix->max - 1;
      vZero = _mm_setzero_si128();
      score = NEG_LIMIT;
      vNegLimit = _mm_set1_epi16(NEG_LIMIT);
      vPosLimit = _mm_set1_epi16(POS_LIMIT);
      vSaturationCheckMin = vPosLimit;
      vSaturationCheckMax = vNegLimit;
      vMaxH = vNegLimit;
      vMaxHUnit = vNegLimit;
      vNegInfFront = vZero;
      vNegInfFront = _mm_insert_epi16(vNegInfFront, NEG_LIMIT, 0);
      vSegLenXgap = _mm_adds_epi16(vNegInfFront,
              _mm_slli_si128(_mm_set1_epi16(-segLen*gap), 2));
  
      /* initialize result */
  #ifdef PARASAIL_TABLE
      result = parasail_result_new_table1(segLen*segWidth, s2Len);
  #else
  #ifdef PARASAIL_ROWCOL
      result = parasail_result_new_rowcol1(segLen*segWidth, s2Len);
  #else
      result = parasail_result_new();
  #endif
  #endif
      if (!result) return NULL;
  
      /* set known flags */
      result->flag |= PARASAIL_FLAG_SW | PARASAIL_FLAG_SCAN
          | PARASAIL_FLAG_BITS_16 | PARASAIL_FLAG_LANES_8;
  #ifdef PARASAIL_TABLE
      result->flag |= PARASAIL_FLAG_TABLE;
  #endif
  #ifdef PARASAIL_ROWCOL
      result->flag |= PARASAIL_FLAG_ROWCOL;
  #endif
  
      /* initialize heap variables */
      pvE = parasail_memalign___m128i(16, segLen);
      pvHt= parasail_memalign___m128i(16, segLen);
      pvH = parasail_memalign___m128i(16, segLen);
      pvHMax = parasail_memalign___m128i(16, segLen);
      pvGapper = parasail_memalign___m128i(16, segLen);
  
      /* validate heap variables */
      if (!pvE) return NULL;
      if (!pvHt) return NULL;
      if (!pvH) return NULL;
      if (!pvHMax) return NULL;
      if (!pvGapper) return NULL;
  
      parasail_memset___m128i(pvH, vZero, segLen);
      parasail_memset___m128i(pvE, vNegLimit, segLen);
      {
          __m128i vGapper = _mm_subs_epi16(vZero,vGapO);
          for (i=segLen-1; i>=0; --i) {
              _mm_store_si128(pvGapper+i, vGapper);
              vGapper = _mm_subs_epi16(vGapper, vGapE);
          }
      }
  
      /* outer loop over database sequence */
      for (j=0; j<s2Len; ++j) {
          __m128i vE;
          __m128i vHt;
          __m128i vF;
          __m128i vH;
          __m128i vHp;
          __m128i *pvW;
          __m128i vW;
  
          /* calculate E */
          /* calculate Ht */
          /* calculate F and H first pass */
          vHp = _mm_load_si128(pvH+(segLen-1));
          vHp = _mm_slli_si128(vHp, 2);
          pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
          vHt = vZero;
          vF = vNegLimit;
          for (i=0; i<segLen; ++i) {
              vH = _mm_load_si128(pvH+i);
              vE = _mm_load_si128(pvE+i);
              vW = _mm_load_si128(pvW+i);
              vE = _mm_max_epi16(
                      _mm_subs_epi16(vE, vGapE),
                      _mm_subs_epi16(vH, vGapO));
              vHp = _mm_adds_epi16(vHp, vW);
              vF = _mm_max_epi16(vF, _mm_adds_epi16(vHt, pvGapper[i]));
              vHt = _mm_max_epi16(vE, vHp);
              _mm_store_si128(pvE+i, vE);
              _mm_store_si128(pvHt+i, vHt);
              vHp = vH;
          }
  
          /* pseudo prefix scan on F and H */
          vHt = _mm_slli_si128(vHt, 2);
          vF = _mm_max_epi16(vF, _mm_adds_epi16(vHt, pvGapper[0]));
          for (i=0; i<segWidth-2; ++i) {
              __m128i vFt = _mm_slli_si128(vF, 2);
              vFt = _mm_adds_epi16(vFt, vSegLenXgap);
              vF = _mm_max_epi16(vF, vFt);
          }
  
          /* calculate final H */
          vF = _mm_slli_si128(vF, 2);
          vF = _mm_adds_epi16(vF, vNegInfFront);
          vH = _mm_max_epi16(vHt, vF);
          vH = _mm_max_epi16(vH, vZero);
          for (i=0; i<segLen; ++i) {
              vHt = _mm_load_si128(pvHt+i);
              vF = _mm_max_epi16(
                      _mm_subs_epi16(vF, vGapE),
                      _mm_subs_epi16(vH, vGapO));
              vH = _mm_max_epi16(vHt, vF);
              vH = _mm_max_epi16(vH, vZero);
              _mm_store_si128(pvH+i, vH);
              vSaturationCheckMin = _mm_min_epi16(vSaturationCheckMin, vH);
              vSaturationCheckMax = _mm_max_epi16(vSaturationCheckMax, vH);
  #ifdef PARASAIL_TABLE
              arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
  #endif
              vMaxH = _mm_max_epi16(vH, vMaxH);
          } 
  
          {
              __m128i vCompare = _mm_cmpgt_epi16(vMaxH, vMaxHUnit);
              if (_mm_movemask_epi8(vCompare)) {
                  score = _mm_hmax_epi16_rpl(vMaxH);
                  vMaxHUnit = _mm_set1_epi16(score);
                  end_ref = j;
                  (void)memcpy(pvHMax, pvH, sizeof(__m128i)*segLen);
              }
          }
  
  #ifdef PARASAIL_ROWCOL
          /* extract last value from the column */
          {
              int32_t k = 0;
              __m128i vH = _mm_load_si128(pvH + offset);
              for (k=0; k<position; ++k) {
                  vH = _mm_slli_si128(vH, 2);
              }
              result->rowcols->score_row[j] = (int16_t) _mm_extract_epi16 (vH, 7);
          }
  #endif
      }
  
      /* Trace the alignment ending position on read. */
      {
          int16_t *t = (int16_t*)pvHMax;
          int32_t column_len = segLen * segWidth;
          end_query = s1Len;
          for (i = 0; i<column_len; ++i, ++t) {
              if (*t == score) {
                  int32_t temp = i / segWidth + i % segWidth * segLen;
                  if (temp < end_query) {
                      end_query = temp;
                  }
              }
          }
      }
  
  #ifdef PARASAIL_ROWCOL
      for (i=0; i<segLen; ++i) {
          __m128i vH = _mm_load_si128(pvH+i);
          arr_store_col(result->rowcols->score_col, vH, i, segLen);
      }
  #endif
  
      if (_mm_movemask_epi8(_mm_or_si128(
              _mm_cmplt_epi16(vSaturationCheckMin, vNegLimit),
              _mm_cmpgt_epi16(vSaturationCheckMax, vPosLimit)))) {
          result->flag |= PARASAIL_FLAG_SATURATED;
          score = 0;
          end_query = 0;
          end_ref = 0;
      }
  
      result->score = score;
      result->end_query = end_query;
      result->end_ref = end_ref;
  
      parasail_free(pvGapper);
      parasail_free(pvHMax);
      parasail_free(pvH);
      parasail_free(pvHt);
      parasail_free(pvE);
  
      return result;
  }
  
  