int main(int argc, char *argv[]) {

std::vector<std::string> results;

//VOLK_PROFILE(volk_16i_x5_add_quad_16i_x4_a, 1e-4, 2046, 10000, &results);

//VOLK_PROFILE(volk_16i_branch_4_state_8_a, 1e-4, 2046, 10000, &results);

VOLK_PROFILE(volk_16ic_s32f_deinterleave_real_32f_a, 1e-5, 32768.0, 204600, 10000, &results);

#this file is generated by volk_profile.\n\

#the function name is followed by the preferred architecture.\n\

";

BOOST_FOREACH(std::string result, results) {

config << result << std::endl;

}

HINTS ${PC_ORC_TOOLSDIR}

PATHS ${ORC_ROOT}/bin ${CMAKE_INSTALL_PREFIX}/bin)

HINTS ${PC_ORC_INCLUDEDIR}

PATHS ${ORC_ROOT}/include/orc-0.4 ${CMAKE_INSTALL_PREFIX}/include/orc-0.4)

HINTS ${PC_ORC_LIBDIR}

PATHS ${ORC_ROOT}/lib${LIB_SUFFIX} ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX})

HINTS ${PC_ORC_LIBRARY_DIRS}

PATHS ${ORC_ROOT}/lib${LIB_SUFFIX} ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX})

<flag>m32</flag>

<overrule>MD_SUBCPU</overrule>

<overrule_val>x86_64</overrule_val>

<arch name="64" type="x86">

<op>0x80000001</op>

extern struct volk_machine *volk_machines[];

extern unsigned int n_volk_machines;

static struct volk_machine *machine = NULL;

if(machine != NULL) return machine;

else {

unsigned int max_score = 0;

}

"""

for i in range(len(functions)):

tempstring += "void get_" + functions[i] + replace_arch.sub("", arched_arglist[i]) + "\n"

tempstring += " %s = get_machine()->%s_archs[volk_rank_archs(get_machine()->%s_indices, get_machine()->%s_arch_defs, get_machine()->%s_n_archs, get_machine()->%s_name, volk_get_lvarch())];\n" % (functions[i], functions[i], functions[i], functions[i], functions[i], functions[i])

return tempstring;

#!/usr/bin/env python

#

# Copyright 2011 Free Software Foundation, Inc.

# This file is part of GNU Radio

# GNU Radio 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, or (at your option)

# any later version.

# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

from xml.dom import minidom

def make_cpuid_c(dom) :

tempstring = HEADER_TEMPL;

for domarch in dom:

if str(domarch.attributes["type"].value) == "x86":

if "no_test" in domarch.attributes.keys():

val = domarch.getElementsByTagName("val");

if val:

val = str(val[0].firstChild.data);

if no_test:

tempstring = tempstring + """\

int i_can_has_%s () {

return 0;

#endif

}

""" % (arch)

elif op == "1":

tempstring = tempstring + """\

int i_can_has_%s () {

}

""" % (arch, val, reg, op, shift, val)

elif str(domarch.attributes["type"].value) == "powerpc":

arch = str(domarch.attributes["name"].value);

tempstring = tempstring + """\

unsigned int found_neon = 0;

auxvec_f = fopen("/proc/self/auxv", "rb");

if(!auxvec_f) return 0;

//so auxv is basically 32b of ID and 32b of value

//so it goes like this

while(!found_neon && auxvec_f) {

if((auxvec[0] == AT_HWCAP) && (auxvec[1] & HWCAP_NEON))

found_neon = 1;

}

fclose(auxvec_f);

return found_neon;

}

""" % (arch)

elif str(domarch.attributes["type"].value) == "all":

arch = str(domarch.attributes["name"].value);

tempstring = tempstring + """\

}

""" % (arch)

tempstring = tempstring + "void volk_cpu_init() {\n";

for domarch in dom:

arch = str(domarch.attributes["name"].value);

return tempstring;

#!/usr/bin/env python

#

# Copyright 2011 Free Software Foundation, Inc.

# This file is part of GNU Radio

# GNU Radio 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, or (at your option)

# any later version.

# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

from xml.dom import minidom

tempstring = tempstring + "\n";

tempstring = tempstring + "__VOLK_DECL_END\n";

tempstring = tempstring + "#endif /*INCLUDED_VOLK_CPU_H*/\n"

return tempstring;

"""

for arch in archs:

tempstring += "#define LV_HAVE_" + arch.swapcase() + " 1\n"

tempstring += """

#include <volk/volk_common.h>

#include "volk_machines.h"

tempstring = tempstring + "#endif\n"

tempstring = tempstring + '\n\n';

tempstring = tempstring + "void volk_environment_init(){\n"

for domarch in dom:

arch = str(domarch.attributes["name"].value);

envs = domarch.getElementsByTagName("environment");

cmd = str(env.firstChild.data);

tempstring = tempstring + "#ifdef LV_HAVE_" + arch.swapcase() + "\n";

tempstring = tempstring + " " + cmd + "\n";

tempstring = tempstring + "}\n";

return tempstring;

tempstring = tempstring + "__VOLK_DECL_END\n";

tempstring = tempstring + "#endif\n"

return tempstring;

tempstring = tempstring + "#endif /*INCLUDED_VOLK_RUNTIME*/\n";

return tempstring;

tempstring += "&volk_machine_" + machine

tempstring += ","

tempstring += "\n#endif\n"

tempstring += r"""

};

unsigned int n_volk_machines = sizeof(volk_machines)/sizeof(*volk_machines);

tempstring += " const int %s_arch_defs[%d];\n"%(function, len(archs))

tempstring += " const %s %s_archs[%d];\n"%(replace_volk.sub("p", function), function, len(archs))

tempstring += " const int %s_n_archs;\n"%function

tempstring += r"""};

"""

for machine in machines:

tempstring += """#if LV_MACHINE_""" + machine.swapcase() + "\n"

tempstring += "extern struct volk_machine volk_machine_" + machine + ";\n"

tempstring += """#endif\n"""

tempstring += r"""

__VOLK_DECL_END

tempstring = r"""

# This file is automatically generated by make_makefile_am.py.

# Do not edit this file.

include $(top_srcdir)/Makefile.common

AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) \

volk_orc_LDFLAGS = $(ORC_LDFLAGS) -lorc-0.4

volk_orc_LIBADD = ../orc/libvolk_orc.la

else

volk_orc_LDFLAGS =

endif

libvolk_la_CPPFLAGS = $(AM_CPPFLAGS) $(volk_orc_CFLAGS)

libvolk_la_LDFLAGS = $(NO_UNDEFINED) -version-info 0:0:0 $(volk_orc_LDFLAGS)

libvolk_la_LIBADD = $(volk_orc_LIBADD)

"""

#here be dragons

for arch in machines[machine_name]:

if archflags_dict[arch] != "none":

tempstring += "-" + archflags_dict[arch] + " "

tempstring += "\nnoinst_LTLIBRARIES += libvolk_" + machine_name + ".la "

tempstring += "\nlibvolk_la_LIBADD += libvolk_" + machine_name + ".la\n"

tempstring += "libvolk_la_CPPFLAGS += -DLV_MACHINE_" + machine_name.swapcase() + " \n"

#!/usr/bin/env python

#

# Copyright 2011 Free Software Foundation, Inc.

# This file is part of GNU Radio

# GNU Radio 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, or (at your option)

# any later version.

# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

from xml.dom import minidom

tempstring = tempstring + " }\n";

tempstring = tempstring + "}\n";

tempstring = tempstring + "\n\n";

tempstring = tempstring + "int main() {\n";

tempstring = tempstring + " volk_cpu_init();\n";

tempstring = tempstring + " char buf[2048];\n";

tempstring = tempstring + " indLV_ARCH=no\n";

tempstring = tempstring + " AC_ARG_WITH(lv_arch,\n";

tempstring = tempstring + " AC_HELP_STRING([--with-lv_arch=ARCH],[set volk hardware speedups as space separated string with elements from the following list(";

for domarch in dom:

arch = str(domarch.attributes["name"].value);

tempstring = tempstring + arch + ", "

tempstring = tempstring[0:len(tempstring) - 2];

tempstring = tempstring + ")]),\n";

tempstring = tempstring + " [cf_with_lv_arch=\"$withval\"],\n";

tempstring = tempstring + " [cf_with_lv_arch=\"\"])\n";

if str(domarch.attributes["type"].value) == "all":

tempstring = tempstring + " AC_DEFINE(LV_MAKE_" + arch.swapcase() + ", 1, [always set "+ arch + "!])\n";

tempstring = tempstring + " ADDONS=\"\"\n";

tempstring = tempstring + " BUILT_ARCHS=\"\"\n";

tempstring = tempstring[0:-1] + "\"\n";

tempstring = tempstring + " OVERRULE_FLAG=\"yes\"\n";

tempstring = tempstring + " fi\n";

tempstring = tempstring +'\ndnl init LV_MAKE_XXX and then try to add archs\n';

for domarch in dom:

if str(domarch.attributes["type"].value) != "all":

tempstring = tempstring + " if test -n \"" + overrule + "\" && test \"$" + overrule + "\" == \"" + overrule_val + "\" && test \"$OVERRULE_FLAG\" == \"yes\" && test \"$indLV_ARCH\" == \"yes\"; then\n"

tempstring = tempstring + " indLV_ARCH=no\n"

tempstring = tempstring + " fi\n"

#tempstring = tempstring + " ADDONS=\"${ADDONS} -" + flag + "\"\n";

tempstring = tempstring + " BUILT_ARCHS=\"${BUILT_ARCHS} " + arch + "\"\n";

tempstring = tempstring + " LV_MAKE_" + arch.swapcase() + "=yes\n";

tempstring = tempstring + " if test -n \"" + overrule + "\" && test \"$" + overrule + "\" == \"" + overrule_val + "\" && test \"$OVERRULE_FLAG\" == \"yes\" && test \"$indLV_ARCH\" == \"yes\"; then\n"

tempstring = tempstring + " indLV_ARCH=no\n"

tempstring = tempstring + " fi\n"

tempstring = tempstring + " LV_MAKE_" + arch.swapcase() + "=yes\n";

tempstring = tempstring + " BUILT_ARCHS=\"${BUILT_ARCHS} " + arch + "\"\n";

tempstring = tempstring + " fi\n"

tempstring = tempstring + " indLV_ARCH=no\n"

for domarch in dom:

arch = str(domarch.attributes["name"].value);

tempstring = tempstring + " AM_CONDITIONAL(LV_MAKE_" + arch.swapcase() + ", test \"$LV_MAKE_" + arch.swapcase() + "\" == \"yes\")\n";

tempstring += "\n"

#now we can define the machines we're compiling

for machine_name in machines:

marchlist = machines[machine_name]

for march in marchlist:

tempstring += "test \"$LV_MAKE_" + march.swapcase() + "\" == \"yes\" && "

tempstring += "test true)\n" #just so we don't have to detect the last one in the group, i know

tempstring = tempstring + " LV_CXXFLAGS=\"${LV_CXXFLAGS} ${ADDONS}\"\n"

tempstring = tempstring + "])\n"

return tempstring;

tempstring = tempstring + '\n';

tempstring = tempstring + "typedef " + retlist[i] +" (*" + replace_volk.sub("p", funclist[i]) + ")(" + my_argtypelist[i] + ");\n";

tempstring = tempstring + "#endif /*INCLUDED_VOLK_TYPEDEFS*/\n";

subdtype = re.search("[0-9]+[A-z]+", dtype);

if subdtype:

datatypes.append(subdtype.group(0));

datatypes = set(datatypes);

if dt in line:

subline = re.search("(volk_" + dt +"_.*(a|u).*\.h)", line);

if subline:

subsubline = re.search(".+(?=\.h)", subline.group(0));

functions.append(subsubline.group(0));

filearchs = afile.getElementsByTagName("arch");

for filearch in filearchs:

archs.append(str(filearch.attributes["name"].value));

for arch in archs:

a_var = re.search("^\$", arch);

if a_var:

archs.remove(arch);

archflags_dict = {}

for filearch in filearchs:

tag = re.search("\w+", tag.group(0));

if tag:

tags.append(tag.group(0));

if begun_name == 0:

retline = re.search(".+(?=" + func + ")", line);

if retline:

ret = retline.group(0);

subline = re.search(func + ".*", line);

if subline:

subsubline = re.search("\(.*?\)", subline.group(0));

if subsubline:

args = subsubline.group(0);

else:

begun_name = 1;

subsubline = re.search("\(.*", subline.group(0));

if subline:

args = subline.group(0);

begun_name = 0;

subline = re.search("\(.*", line);

if subline:

args = subline.group(0);

begun_paren = 1;

replace = re.compile("static ");

ret = replace.sub("", ret);

replace = re.compile("inline ");

ret = replace.sub("", ret);

replace = re.compile("\)");

arched_args = replace.sub(", const char* arch) {", args);

remove = re.compile('\)|\(|{');

rargs = remove.sub("", args);

sargs = rargs.split(',');

margs = [];

atypes = [];

for arg in sargs:

replace = re.compile(" " + temp[-1]);

atypes.append(replace.sub("", arg));

my_args = ""

arg_types = ""

for arg in range(0, len(margs) - 1):

this_type = leading_space_remove.sub("", atypes[-1]);

arg_types = arg_types + this_type;

my_argtypelist.append(arg_types);

if(ret[-1] != ' '):

ret = ret + ' ';

my_arglist.append(my_args) #!!!!!!!!!!!!!!!!!

retlist.append(ret);

fcountlist.append(fcount);

outfile_cpu_h.write(make_cpuid_h(filearchs));

#include<inttypes.h>

#include<tmmintrin.h>

static inline void volk_16i_branch_4_state_8_a_ssse3(short* target, short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars) {

__m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11;

__m128i *p_target, *p_src0, *p_cntl2, *p_cntl3, *p_scalars;

p_target = (__m128i*)target;

p_src0 = (__m128i*)src0;

p_cntl2 = (__m128i*)cntl2;

p_cntl3 = (__m128i*)cntl3;

p_scalars = (__m128i*)scalars;

int i = 0;

int bound = 1;

xmm0 = _mm_load_si128(p_scalars);

xmm1 = _mm_shufflelo_epi16(xmm0, 0);

xmm2 = _mm_shufflelo_epi16(xmm0, 0x55);

xmm3 = _mm_shufflelo_epi16(xmm0, 0xaa);

xmm4 = _mm_shufflelo_epi16(xmm0, 0xff);

xmm1 = _mm_shuffle_epi32(xmm1, 0x00);

xmm2 = _mm_shuffle_epi32(xmm2, 0x00);

xmm3 = _mm_shuffle_epi32(xmm3, 0x00);

xmm10 = _mm_load_si128((__m128i*)permuters[3]);

for(; i < bound; ++i) {

xmm5 = _mm_load_si128(p_src0);

xmm0 = _mm_shuffle_epi8(xmm5, xmm0);

xmm6 = _mm_shuffle_epi8(xmm5, xmm6);

xmm8 = _mm_shuffle_epi8(xmm5, xmm8);

xmm10 = _mm_shuffle_epi8(xmm5, xmm10);

p_src0 += 4;

xmm5 = _mm_add_epi16(xmm1, xmm2);

xmm6 = _mm_add_epi16(xmm2, xmm6);

xmm8 = _mm_add_epi16(xmm1, xmm8);

xmm7 = _mm_load_si128(p_cntl2);

xmm9 = _mm_load_si128(p_cntl3);

xmm0 = _mm_add_epi16(xmm5, xmm0);

xmm7 = _mm_and_si128(xmm7, xmm3);

xmm9 = _mm_and_si128(xmm9, xmm4);

xmm5 = _mm_load_si128(&p_cntl2[1]);

xmm11 = _mm_load_si128(&p_cntl3[1]);

xmm11 = _mm_and_si128(xmm11, xmm4);

xmm0 = _mm_add_epi16(xmm0, xmm7);

xmm7 = _mm_load_si128(&p_cntl2[2]);

xmm9 = _mm_load_si128(&p_cntl3[2]);

xmm5 = _mm_add_epi16(xmm5, xmm11);

xmm7 = _mm_and_si128(xmm7, xmm3);

xmm9 = _mm_and_si128(xmm9, xmm4);

xmm6 = _mm_add_epi16(xmm6, xmm5);

xmm5 = _mm_load_si128(&p_cntl2[3]);

xmm11 = _mm_load_si128(&p_cntl3[3]);

xmm7 = _mm_add_epi16(xmm7, xmm9);

xmm5 = _mm_and_si128(xmm5, xmm3);

xmm11 = _mm_and_si128(xmm11, xmm4);

xmm8 = _mm_add_epi16(xmm8, xmm7);

xmm5 = _mm_add_epi16(xmm5, xmm11);

_mm_store_si128(p_target, xmm0);

_mm_store_si128(&p_target[1], xmm6);

xmm10 = _mm_add_epi16(xmm5, xmm10);

_mm_store_si128(&p_target[2], xmm8);

_mm_store_si128(&p_target[3], xmm10);

}

}

#endif /*LV_HAVE_SSEs*/

#ifdef LV_HAVE_GENERIC

static inline void volk_16i_branch_4_state_8_a_generic(short* target, short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars) {

int i = 0;

int bound = 4;

for(; i < bound; ++i) {

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8] & scalars[2])

+ (cntl3[i * 8] & scalars[3]);

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8 + 1] & scalars[2])

+ (cntl3[i * 8 + 1] & scalars[3]);

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8 + 2] & scalars[2])

+ (cntl3[i * 8 + 2] & scalars[3]);

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8 + 3] & scalars[2])

+ (cntl3[i * 8 + 3] & scalars[3]);

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8 + 4] & scalars[2])

+ (cntl3[i * 8 + 4] & scalars[3]);

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8 + 5] & scalars[2])

+ (cntl3[i * 8 + 5] & scalars[3]);

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8 + 6] & scalars[2])

+ (cntl3[i * 8 + 6] & scalars[3]);

+ ((i + 1)%2 * scalars[0])

+ (((i >> 1)^1) * scalars[1])

+ (cntl2[i * 8 + 7] & scalars[2])

+ (cntl3[i * 8 + 7] & scalars[3]);

}

}

static inline void volk_16i_convert_8i_a_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){

unsigned int number = 0;

const unsigned int sixteenthPoints = num_points / 16;

int8_t* outputVectorPtr = outputVector;

int16_t* inputPtr = (int16_t*)inputVector;

__m128i inputVal1;

inputVal1 = _mm_srai_epi16(inputVal1, 8);

inputVal2 = _mm_srai_epi16(inputVal2, 8);

ret = _mm_packs_epi16(inputVal1, inputVal2);

_mm_store_si128((__m128i*)outputVectorPtr, ret);

static inline void volk_16i_convert_8i_u_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){

unsigned int number = 0;

const unsigned int sixteenthPoints = num_points / 16;

int8_t* outputVectorPtr = outputVector;

int16_t* inputPtr = (int16_t*)inputVector;

__m128i inputVal1;

inputVal1 = _mm_srai_epi16(inputVal1, 8);

inputVal2 = _mm_srai_epi16(inputVal2, 8);

ret = _mm_packs_epi16(inputVal1, inputVal2);

_mm_storeu_si128((__m128i*)outputVectorPtr, ret);

#include<inttypes.h>

#ifdef LV_HAVE_SSSE3

static inline void volk_16i_max_star_16i_a_ssse3(short* target, short* src0, unsigned int num_bytes) {

short candidate = src0[0];

short cands[8];

__m128i xmm0, xmm1, xmm3, xmm4, xmm5, xmm6;

__m128i *p_src0;

p_src0 = (__m128i*)src0;

int bound = num_bytes >> 4;

int leftovers = (num_bytes >> 1) & 7;

int i = 0;

xmm1 = _mm_setzero_si128();

xmm0 = _mm_setzero_si128();

//_mm_insert_epi16(xmm0, candidate, 0);

for(i = 0; i < bound; ++i) {

xmm1 = _mm_load_si128(p_src0);

p_src0 += 1;

//xmm2 = _mm_sub_epi16(xmm1, xmm0);

xmm3 = _mm_cmpgt_epi16(xmm0, xmm1);

xmm4 = _mm_cmpeq_epi16(xmm0, xmm1);

xmm5 = _mm_cmpgt_epi16(xmm1, xmm0);

xmm6 = _mm_xor_si128(xmm4, xmm5);

xmm3 = _mm_and_si128(xmm3, xmm0);

xmm4 = _mm_and_si128(xmm6, xmm1);

xmm0 = _mm_add_epi16(xmm3, xmm4);

}

_mm_store_si128((__m128i*)cands, xmm0);

for(i = 0; i < 8; ++i) {

candidate = ((short)(candidate - cands[i]) > 0) ? candidate : cands[i];

}

for(i = 0; i < leftovers; ++i) {

candidate = ((short)(candidate - src0[(bound << 3) + i]) > 0) ? candidate : src0[(bound << 3) + i];

}

target[0] = candidate;

#endif /*LV_HAVE_SSSE3*/

#ifdef LV_HAVE_GENERIC

static inline void volk_16i_max_star_16i_a_generic(short* target, short* src0, unsigned int num_bytes) {

int i = 0;

int bound = num_bytes >> 1;

short candidate = src0[0];

candidate = ((short)(candidate - src0[i]) > 0) ? candidate : src0[i];

}

target[0] = candidate;

}

#include <volk/volk_common.h>

#include<inttypes.h>

#ifdef LV_HAVE_SSSE3

const static uint8_t andmask0[16] = {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

const static uint8_t andmask1[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02};

__m128i xmm0, xmm1, xmm2, xmm3, xmm4;

__m128i xmm5, xmm6, xmm7, xmm8;

xmm4 = _mm_load_si128((__m128i*)shufmask0);

xmm5 = _mm_load_si128((__m128i*)shufmask1);

xmm6 = _mm_load_si128((__m128i*)andmask0);

xmm7 = _mm_load_si128((__m128i*)andmask1);

__m128i *p_target, *p_src0;

p_target = (__m128i*)target;

p_src0 = (__m128i*)src0;

int bound = num_bytes >> 5;

int intermediate = (num_bytes >> 4) & 1;

int leftovers = (num_bytes >> 1) & 7;

int i = 0;

for(i = 0; i < bound; ++i) {

xmm0 = _mm_load_si128(p_src0);

xmm1 = _mm_load_si128(&p_src0[1]);

xmm2 = _mm_xor_si128(xmm2, xmm2);

p_src0 += 2;

xmm3 = _mm_hsub_epi16(xmm0, xmm1);

xmm8 = _mm_and_si128(xmm2, xmm6);

xmm3 = _mm_and_si128(xmm2, xmm7);

xmm8 = _mm_add_epi8(xmm8, xmm4);

xmm3 = _mm_add_epi8(xmm3, xmm5);

xmm0 = _mm_shuffle_epi8(xmm0, xmm8);

xmm1 = _mm_shuffle_epi8(xmm1, xmm3);

xmm3 = _mm_add_epi16(xmm0, xmm1);

_mm_store_si128(p_target, xmm3);

p_target += 1;

}

for(i = 0; i < intermediate; ++i) {

xmm0 = _mm_load_si128(p_src0);

xmm2 = _mm_xor_si128(xmm2, xmm2);

p_src0 += 1;

xmm3 = _mm_hsub_epi16(xmm0, xmm1);

xmm2 = _mm_cmpgt_epi16(xmm2, xmm3);

xmm8 = _mm_and_si128(xmm2, xmm6);

xmm3 = _mm_add_epi8(xmm8, xmm4);

xmm0 = _mm_shuffle_epi8(xmm0, xmm3);

_mm_storel_pd((double*)p_target, bit128_p(&xmm0)->double_vec);

p_target = (__m128i*)((int8_t*)p_target + 8);

}

target[i>>1] = ((int16_t)(src0[i] - src0[i + 1]) > 0) ? src0[i] : src0[i + 1];

}

#endif /*LV_HAVE_SSSE3*/

#ifdef LV_HAVE_GENERIC

static inline void volk_16i_max_star_horizontal_16i_a_generic(int16_t* target, int16_t* src0, unsigned int num_bytes) {

int i = 0;

int bound = num_bytes >> 1;

for(i = 0; i < bound; i += 2) {

target[i >> 1] = ((int16_t) (src0[i] - src0[i + 1]) > 0) ? src0[i] : src0[i+1];

}

}

#include<inttypes.h>

#include<emmintrin.h>

static inline void volk_16i_permute_and_scalar_add_a_sse2(short* target, short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_bytes) {

__m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;

__m128i *p_target, *p_cntl0, *p_cntl1, *p_cntl2, *p_cntl3, *p_scalars;

short* p_permute_indexes = permute_indexes;

p_target = (__m128i*)target;

p_cntl0 = (__m128i*)cntl0;

p_cntl1 = (__m128i*)cntl1;

p_cntl2 = (__m128i*)cntl2;

p_cntl3 = (__m128i*)cntl3;

p_scalars = (__m128i*)scalars;

int i = 0;

int bound = (num_bytes >> 4);

int leftovers = (num_bytes >> 1) & 7;

xmm0 = _mm_load_si128(p_scalars);

xmm1 = _mm_shufflelo_epi16(xmm0, 0);

xmm2 = _mm_shufflelo_epi16(xmm0, 0x55);

xmm3 = _mm_shufflelo_epi16(xmm0, 0xaa);

xmm4 = _mm_shufflelo_epi16(xmm0, 0xff);

xmm1 = _mm_shuffle_epi32(xmm1, 0x00);

xmm2 = _mm_shuffle_epi32(xmm2, 0x00);

xmm3 = _mm_shuffle_epi32(xmm3, 0x00);

xmm0 = _mm_add_epi16(xmm0, xmm5);

xmm6 = _mm_add_epi16(xmm6, xmm7);

p_permute_indexes += 8;

xmm0 = _mm_add_epi16(xmm0, xmm6);

xmm5 = _mm_load_si128(p_cntl0);

xmm6 = _mm_load_si128(p_cntl1);

xmm7 = _mm_load_si128(p_cntl2);

xmm5 = _mm_and_si128(xmm5, xmm1);

xmm6 = _mm_and_si128(xmm6, xmm2);

xmm7 = _mm_and_si128(xmm7, xmm3);

xmm0 = _mm_add_epi16(xmm0, xmm5);

xmm5 = _mm_load_si128(p_cntl3);

xmm6 = _mm_add_epi16(xmm6, xmm7);

p_cntl0 += 1;

xmm5 = _mm_and_si128(xmm5, xmm4);

xmm0 = _mm_add_epi16(xmm0, xmm6);

p_cntl1 += 1;

p_cntl2 += 1;

p_cntl3 += 1;

_mm_store_si128(p_target, xmm0);

p_target += 1;

}

for(i = bound * 8; i < (bound * 8) + leftovers; ++i) {

+ (cntl0[i] & scalars[0])

+ (cntl1[i] & scalars[1])

+ (cntl2[i] & scalars[2])

#ifdef LV_HAVE_GENERIC

static inline void volk_16i_permute_and_scalar_add_a_generic(short* target, short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_bytes) {

int i = 0;

int bound = num_bytes >> 1;

for(i = 0; i < bound; ++i) {

+ (cntl0[i] & scalars[0])

+ (cntl1[i] & scalars[1])

+ (cntl2[i] & scalars[2])

+ (cntl3[i] & scalars[3]);

}

}

static inline void volk_16i_s32f_convert_32f_a_sse4_1(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int eighthPoints = num_points / 8;

float* outputVectorPtr = outputVector;

__m128 invScalar = _mm_set_ps1(1.0/scalar);

int16_t* inputPtr = (int16_t*)inputVector;

// Convert the lower 4 values into 32 bit words

inputVal = _mm_cvtepi16_epi32(inputVal);

inputVal2 = _mm_cvtepi16_epi32(inputVal2);

ret = _mm_cvtepi32_ps(inputVal);

ret = _mm_mul_ps(ret, invScalar);

_mm_storeu_ps(outputVectorPtr, ret);

static inline void volk_16i_s32f_convert_32f_a_sse(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

float* outputVectorPtr = outputVector;

__m128 invScalar = _mm_set_ps1(1.0/scalar);

int16_t* inputPtr = (int16_t*)inputVector;

for(;number < quarterPoints; number++){

ret = _mm_set_ps((float)(inputPtr[3]), (float)(inputPtr[2]), (float)(inputPtr[1]), (float)(inputPtr[0]));

ret = _mm_mul_ps(ret, invScalar);

_mm_storeu_ps(outputVectorPtr, ret);

static inline void volk_16i_s32f_convert_32f_u_sse4_1(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int eighthPoints = num_points / 8;

float* outputVectorPtr = outputVector;

__m128 invScalar = _mm_set_ps1(1.0/scalar);

int16_t* inputPtr = (int16_t*)inputVector;

// Convert the lower 4 values into 32 bit words

inputVal = _mm_cvtepi16_epi32(inputVal);

inputVal2 = _mm_cvtepi16_epi32(inputVal2);

ret = _mm_cvtepi32_ps(inputVal);

ret = _mm_mul_ps(ret, invScalar);

_mm_storeu_ps(outputVectorPtr, ret);

static inline void volk_16i_s32f_convert_32f_u_sse(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

float* outputVectorPtr = outputVector;

__m128 invScalar = _mm_set_ps1(1.0/scalar);

int16_t* inputPtr = (int16_t*)inputVector;

for(;number < quarterPoints; number++){

ret = _mm_set_ps((float)(inputPtr[3]), (float)(inputPtr[2]), (float)(inputPtr[1]), (float)(inputPtr[0]));

ret = _mm_mul_ps(ret, invScalar);

_mm_storeu_ps(outputVectorPtr, ret);

#include<inttypes.h>

#include<emmintrin.h>

static inline void volk_16i_x4_quad_max_star_16i_a_sse2(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_bytes) {

int bound = (num_bytes >> 4);

int bound_copy = bound;

int leftovers = (num_bytes >> 1) & 7;

__m128i *p_target, *p_src0, *p_src1, *p_src2, *p_src3;

p_target = (__m128i*) target;

p_src0 = (__m128i*)src0;

p_src1 = (__m128i*)src1;

p_src2 = (__m128i*)src2;

p_src3 = (__m128i*)src3;

__m128i xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8;

while(bound_copy > 0) {

xmm1 = _mm_load_si128(p_src0);

xmm2 = _mm_load_si128(p_src1);

xmm3 = _mm_load_si128(p_src2);

xmm4 = _mm_load_si128(p_src3);

xmm5 = _mm_setzero_si128();

xmm6 = _mm_setzero_si128();

xmm7 = xmm1;

xmm8 = xmm3;

xmm1 = _mm_sub_epi16(xmm2, xmm1);

xmm3 = _mm_sub_epi16(xmm4, xmm3);

xmm5 = _mm_cmpgt_epi16(xmm1, xmm5);

xmm6 = _mm_cmpgt_epi16(xmm3, xmm6);

xmm2 = _mm_and_si128(xmm5, xmm2);

xmm4 = _mm_and_si128(xmm6, xmm4);

xmm5 = _mm_add_epi16(xmm2, xmm5);

xmm6 = _mm_add_epi16(xmm4, xmm6);

xmm1 = _mm_xor_si128(xmm1, xmm1);

xmm2 = xmm5;

xmm5 = _mm_sub_epi16(xmm6, xmm5);

xmm1 = _mm_cmpgt_epi16(xmm5, xmm1);

p_src1 += 1;

xmm6 = _mm_and_si128(xmm1, xmm6);

xmm1 = _mm_andnot_si128(xmm1, xmm2);

p_src2 += 1;

xmm1 = _mm_add_epi16(xmm6, xmm1);

p_src3 += 1;

_mm_store_si128(p_target, xmm1);

p_target += 1;

}

/*asm volatile

(

"movaps %%xmm3, %%xmm8\n\t"

"psubw %%xmm2, %%xmm1\n\t"

"psubw %%xmm4, %%xmm3\n\t"

"pcmpgtw %%xmm1, %%xmm5\n\t"

"pcmpgtw %%xmm3, %%xmm6\n\t"

"pand %%xmm5, %%xmm2\n\t"

"pand %%xmm6, %%xmm4\n\t"

"pandn %%xmm7, %%xmm5\n\t"

"pandn %%xmm8, %%xmm6\n\t"

"paddw %%xmm2, %%xmm5\n\t"

"paddw %%xmm4, %%xmm6\n\t"

"pxor %%xmm1, %%xmm1\n\t"

"movaps %%xmm5, %%xmm2\n\t"

"psubw %%xmm6, %%xmm5\n\t"

"add $16, %[src0]\n\t"

"add $-1, %[bound]\n\t"

"pcmpgtw %%xmm5, %%xmm1\n\t"

"add $16, %[src1]\n\t"

"movaps %%xmm1, (%[target])\n\t"

"addw $16, %[target]\n\t"

"jmp volk_16i_x4_quad_max_star_16i_a_sse2_L1\n\t"

"volk_16i_x4_quad_max_star_16i_a_sse2_END:\n\t"

:

:[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2), [src3]"r"(src3), [target]"r"(target)

:

);

short temp0 = 0;

short temp1 = 0;

#ifdef LV_HAVE_GENERIC

static inline void volk_16i_x4_quad_max_star_16i_a_generic(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_bytes) {

int i = 0;

int bound = num_bytes >> 1;

short temp0 = 0;

short temp1 = 0;

for(i = 0; i < bound; ++i) {

#include<inttypes.h>

#include<emmintrin.h>

static inline void volk_16i_x5_add_quad_16i_x4_a_sse2(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_bytes) {

__m128i xmm0, xmm1, xmm2, xmm3, xmm4;

__m128i *p_target0, *p_target1, *p_target2, *p_target3, *p_src0, *p_src1, *p_src2, *p_src3, *p_src4;

p_target0 = (__m128i*)target0;

xmm2 = _mm_load_si128(p_src2);

xmm3 = _mm_load_si128(p_src3);

xmm4 = _mm_load_si128(p_src4);

p_src0 += 1;

p_src1 += 1;

xmm1 = _mm_add_epi16(xmm0, xmm1);

xmm2 = _mm_add_epi16(xmm0, xmm2);

xmm3 = _mm_add_epi16(xmm0, xmm3);

xmm4 = _mm_add_epi16(xmm0, xmm4);

p_src2 += 1;

p_src3 += 1;

p_src4 += 1;

_mm_store_si128(p_target1, xmm2);

_mm_store_si128(p_target2, xmm3);

_mm_store_si128(p_target3, xmm4);

p_target0 += 1;

p_target1 += 1;

p_target2 += 1;

:[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2), [src3]"r"(src3), [src4]"r"(src4), [target0]"r"(target0), [target1]"r"(target1), [target2]"r"(target2), [target3]"r"(target3)

:"xmm1", "xmm2", "xmm3", "xmm4", "xmm5"

);

*/

for(i = bound * 8; i < (bound * 8) + leftovers; ++i) {

target0[i] = src0[i] + src1[i];

#ifdef LV_HAVE_GENERIC

static inline void volk_16i_x5_add_quad_16i_x4_a_generic(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_bytes) {

int i = 0;

int bound = num_bytes >> 1;

for(i = 0; i < bound; ++i) {

__m128i highMask = _mm_set_epi32(0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0x0);

unsigned int eighthPoints = num_points / 8;

for(number = 0; number < eighthPoints; number++){

complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;

complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;

__m128i highMask = _mm_set_epi32(0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0x0);

unsigned int eighthPoints = num_points / 8;

for(number = 0; number < eighthPoints; number++){

complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;

complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;

static inline void volk_16ic_magnitude_16i_a_sse3(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const int16_t* complexVectorPtr = (const int16_t*)complexVector;

int16_t* magnitudeVectorPtr = magnitudeVector;

inputFloatBuffer[1] = (float)(complexVectorPtr[1]);

inputFloatBuffer[2] = (float)(complexVectorPtr[2]);

inputFloatBuffer[3] = (float)(complexVectorPtr[3]);

inputFloatBuffer[4] = (float)(complexVectorPtr[4]);

inputFloatBuffer[5] = (float)(complexVectorPtr[5]);

inputFloatBuffer[6] = (float)(complexVectorPtr[6]);

inputFloatBuffer[1] = (float)(complexVectorPtr[1]);

inputFloatBuffer[2] = (float)(complexVectorPtr[2]);

inputFloatBuffer[3] = (float)(complexVectorPtr[3]);

cplxValue1 = _mm_load_ps(inputFloatBuffer);

complexVectorPtr += 4;

float* qBufferPtr = qBuffer;

uint64_t number = 0;

__m128 cplxValue1, cplxValue2, iValue, qValue;

__m128 invScalar = _mm_set_ps1(1.0/scalar);

__VOLK_ATTR_ALIGNED(16) float floatBuffer[8];

for(;number < quarterPoints; number++){

floatBuffer[0] = (float)(complexVectorPtr[0]);

floatBuffer[1] = (float)(complexVectorPtr[1]);

floatBuffer[2] = (float)(complexVectorPtr[2]);

floatBuffer[3] = (float)(complexVectorPtr[3]);

floatBuffer[4] = (float)(complexVectorPtr[4]);

floatBuffer[5] = (float)(complexVectorPtr[5]);

floatBuffer[6] = (float)(complexVectorPtr[6]);

float* iBufferPtr = iBuffer;

unsigned int number = 0;

__m128 iFloatValue;

*iBufferPtr++ = ((float)(*sixteenTComplexVectorPtr++)) * iScalar;

sixteenTComplexVectorPtr++;

}

}

#endif /* LV_HAVE_SSE4_1 */

float* iBufferPtr = iBuffer;

unsigned int number = 0;

__m128 iValue;

const float iScalar = 1.0/scalar;

for(;number < quarterPoints; number++){

floatBuffer[0] = (float)(*complexVectorPtr); complexVectorPtr += 2;

floatBuffer[2] = (float)(*complexVectorPtr); complexVectorPtr += 2;

floatBuffer[3] = (float)(*complexVectorPtr); complexVectorPtr += 2;

*iBufferPtr++ = ((float)(*complexVectorPtr++)) * iScalar;

complexVectorPtr++;

}

}

#endif /* LV_HAVE_SSE */

static inline void volk_16ic_s32f_magnitude_32f_a_sse3(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const int16_t* complexVectorPtr = (const int16_t*)complexVector;

float* magnitudeVectorPtr = magnitudeVector;

inputFloatBuffer[1] = (float)(complexVectorPtr[1]);

inputFloatBuffer[2] = (float)(complexVectorPtr[2]);

inputFloatBuffer[3] = (float)(complexVectorPtr[3]);

inputFloatBuffer[4] = (float)(complexVectorPtr[4]);

inputFloatBuffer[5] = (float)(complexVectorPtr[5]);

inputFloatBuffer[6] = (float)(complexVectorPtr[6]);

result = _mm_sqrt_ps(result); // Square root the values

_mm_store_ps(magnitudeVectorPtr, result);

magnitudeVectorPtr += 4;

}

inputFloatBuffer[1] = (float)(complexVectorPtr[1]);

inputFloatBuffer[2] = (float)(complexVectorPtr[2]);

inputFloatBuffer[3] = (float)(complexVectorPtr[3]);

inputFloatBuffer[4] = (float)(complexVectorPtr[4]);

inputFloatBuffer[5] = (float)(complexVectorPtr[5]);

inputFloatBuffer[6] = (float)(complexVectorPtr[6]);

cplxValue1 = _mm_load_ps(&inputFloatBuffer[0]);

cplxValue2 = _mm_load_ps(&inputFloatBuffer[4]);

re = _mm_shuffle_ps(cplxValue1, cplxValue2, 0x88);

im = _mm_shuffle_ps(cplxValue1, cplxValue2, 0xdd);

result = _mm_sqrt_ps(result); // Square root the values

_mm_store_ps(magnitudeVectorPtr, result);

magnitudeVectorPtr += 4;

}

}

}

#endif /* LV_HAVE_SSE */

#ifdef LV_HAVE_GENERIC

inputPtr += 8;

}

// Byteswap any remaining points:

for(; number < num_points; number++){

uint16_t outputVal = *inputPtr;

outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));

const float* aPtr = inputBuffer;

__VOLK_ATTR_ALIGNED(16) float tempBuffer[4];

__m128 accumulator = _mm_setzero_ps();

__m128 aVal = _mm_setzero_ps();

for(;number < quarterPoints; number++){

aVal = _mm_load_ps(aPtr);

aPtr += 4;

}

_mm_store_ps(tempBuffer,accumulator); // Store the results back into the C container

returnValue += tempBuffer[1];

returnValue += tempBuffer[2];

returnValue += tempBuffer[3];

number = quarterPoints * 4;

for(;number < num_points; number++){

returnValue += (*aPtr++);

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

double* outputVectorPtr = outputVector;

__m128d ret;

for(;number < quarterPoints; number++){

inputVal = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

ret = _mm_cvtps_pd(inputVal);

_mm_store_pd(outputVectorPtr, ret);

outputVectorPtr += 2;

}

for(; number < num_points; number++){

outputVector[number] = (double)(inputVector[number]);

}

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

double* outputVectorPtr = outputVector;

__m128d ret;

for(;number < quarterPoints; number++){

inputVal = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;

ret = _mm_cvtps_pd(inputVal);

_mm_storeu_pd(outputVectorPtr, ret);

outputVectorPtr += 2;

}

for(; number < num_points; number++){

outputVector[number] = (double)(inputVector[number]);

}

}

number = quarterPoints * 4;

if(src0[number] > max){

index = number;

max = src0[number];

}

number = quarterPoints * 4;

if(src0[number] > max){

index = number;

max = src0[number];

if(num_points > 0){

float max = src0[0];

unsigned int index = 0;

for(; i < num_points; ++i) {

if(src0[i] > max){

index = i;

max = src0[i];

inPtr++;

outPtr++;

}

for (; number < quarterPoints; number++) {

// Load data

next3old1 = _mm_loadu_ps((float*) (inPtr-1));

_mm_store_ps(outPtr,next3old1); // Store the results back into the output

outPtr += 4;

}

for (number = (4 > (quarterPoints*4) ? 4 : (4 * quarterPoints)); number < num_points; number++) {

*outPtr = *(inPtr) - *(inPtr-1);

if (*outPtr > bound) *outPtr -= 2*bound;

inPtr++;

outPtr++;

}

*saveValue = inputVector[num_points-1];

}

#endif /* LV_HAVE_SSE */

unsigned int number = 0;

float* outPtr = outputVector;

const float* inPtr = inputVector;

// Do the first 1 by hand since we're going in from the saveValue:

*outPtr = *inPtr - *saveValue;

if (*outPtr > bound) *outPtr -= 2*bound;

if (*outPtr < -bound) *outPtr += 2*bound;

inPtr++;

outPtr++;

for (number = 1; number < num_points; number++) {

*outPtr = *(inPtr) - *(inPtr-1);

if (*outPtr > bound) *outPtr -= 2*bound;

inPtr++;

outPtr++;

}

*saveValue = inputVector[num_points-1];

}

#endif /* LV_HAVE_GENERIC */

const float* dataPointsPtr = realDataPoints;

__VOLK_ATTR_ALIGNED(16) float avgPointsVector[4];

__m128 dataPointsVal;

__m128 avgPointsVal = _mm_setzero_ps();

// Calculate the sum (for mean) for all points

// Mask off the items that exceed the mean amplitude and add the avg Points that do not exceed the mean amplitude

avgPointsVal = _mm_add_ps(avgPointsVal, _mm_and_ps(compareMask, dataPointsVal));

// Count the number of bins which do not exceed the mean amplitude

vValidBinCount = _mm_add_ps(vValidBinCount, _mm_and_ps(compareMask, vOnesVector));

}

// Calculate the mean from the remaining data points

_mm_store_ps(avgPointsVector, avgPointsVal);

validBinCount += 1.0;

}

}

float localNoiseFloorAmplitude = 0;

if(validBinCount > 0.0){

localNoiseFloorAmplitude = sumMean / validBinCount;

unsigned int number = 0;

const unsigned int eighthPoints = num_points / 8;

const float* inputVectorPtr = (const float*)inputVector;

int16_t* outputVectorPtr = outputVector;

outputVectorPtr += 8;

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

int16_t* outputVectorPtr = outputVector;

*outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int eighthPoints = num_points / 8;

const float* inputVectorPtr = (const float*)inputVector;

int16_t* outputVectorPtr = outputVector;

outputVectorPtr += 8;

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

int16_t* outputVectorPtr = outputVector;

*outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int eighthPoints = num_points / 8;

const float* inputVectorPtr = (const float*)inputVector;

int32_t* outputVectorPtr = outputVector;

outputVectorPtr += 8;

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

int32_t* outputVectorPtr = outputVector;

outputVectorPtr += 4;

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

int32_t* outputVectorPtr = outputVector;

*outputVectorPtr++ = (int32_t)(outputFloatBuffer[3]);

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

int32_t* outputVectorPtr = outputVector;

outputVectorPtr += 4;

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

int32_t* outputVectorPtr = outputVector;

*outputVectorPtr++ = (int32_t)(outputFloatBuffer[3]);

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int sixteenthPoints = num_points / 16;

const float* inputVectorPtr = (const float*)inputVector;

int8_t* outputVectorPtr = outputVector;

intInputVal2 = _mm_cvtps_epi32(inputVal2);

intInputVal3 = _mm_cvtps_epi32(inputVal3);

intInputVal4 = _mm_cvtps_epi32(inputVal4);

intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);

intInputVal3 = _mm_packs_epi32(intInputVal3, intInputVal4);

outputVectorPtr += 16;

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

float min_val = -128;

*outputVectorPtr++ = (int8_t)(outputFloatBuffer[3]);

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int sixteenthPoints = num_points / 16;

const float* inputVectorPtr = (const float*)inputVector;

int8_t* outputVectorPtr = outputVector;

intInputVal2 = _mm_cvtps_epi32(inputVal2);

intInputVal3 = _mm_cvtps_epi32(inputVal3);

intInputVal4 = _mm_cvtps_epi32(inputVal4);

intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);

intInputVal3 = _mm_packs_epi32(intInputVal3, intInputVal4);

outputVectorPtr += 16;

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* inputVectorPtr = (const float*)inputVector;

int8_t* outputVectorPtr = outputVector;

*outputVectorPtr++ = (int8_t)(outputFloatBuffer[3]);

}

for(; number < num_points; number++){

r = inputVector[number] * scalar;

if(r > max_val)

__m128 aVal, bVal, cVal;

bVal = _mm_set_ps1(scalar);

for(;number < quarterPoints; number++){

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m256 aVal, bVal, cVal;

bVal = _mm256_set1_ps(scalar);

for(;number < eighthPoints; number++){

_mm256_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 8;

__m128 aVal, bVal, cVal;

bVal = _mm_set_ps1(scalar);

for(;number < quarterPoints; number++){

_mm_storeu_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m256 aVal, bVal, cVal;

bVal = _mm256_set1_ps(scalar);

for(;number < eighthPoints; number++){

_mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 8;

*/

static inline void volk_32f_s32f_power_32f_a_sse4_1(float* cVector, const float* aVector, const float power, unsigned int num_points){

unsigned int number = 0;

float* cPtr = cVector;

const float* aPtr = aVector;

__m128 negatedValues;

__m128 negativeOneToPower = _mm_set_ps1(powf(-1, power));

__m128 onesMask = _mm_set_ps1(1);

__m128 aVal, cVal;

for(;number < quarterPoints; number++){

aVal = _mm_load_ps(aPtr);

signMask = _mm_cmplt_ps(aVal, zeroValue);

negatedValues = _mm_sub_ps(zeroValue, aVal);

aVal = _mm_blendv_ps(aVal, negatedValues, signMask);

// powf4 doesn't support negative values in the base, so we mask them off and then apply the negative after

cVal = powf4(aVal, vPower); // Takes each input value to the specified power

cVal = _mm_mul_ps( _mm_blendv_ps(onesMask, negativeOneToPower, signMask), cVal);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

cPtr += 4;

}

*/

static inline void volk_32f_s32f_power_32f_a_sse(float* cVector, const float* aVector, const float power, unsigned int num_points){

unsigned int number = 0;

float* cPtr = cVector;

const float* aPtr = aVector;

__m128 negatedValues;

__m128 negativeOneToPower = _mm_set_ps1(powf(-1, power));

__m128 onesMask = _mm_set_ps1(1);

__m128 aVal, cVal;

for(;number < quarterPoints; number++){

aVal = _mm_load_ps(aPtr);

signMask = _mm_cmplt_ps(aVal, zeroValue);

negatedValues = _mm_sub_ps(zeroValue, aVal);

aVal = _mm_or_ps(_mm_andnot_ps(signMask, aVal), _mm_and_ps(signMask, negatedValues) );

// powf4 doesn't support negative values in the base, so we mask them off and then apply the negative after

cVal = powf4(aVal, vPower); // Takes each input value to the specified power

cVal = _mm_mul_ps( _mm_or_ps( _mm_andnot_ps(signMask, onesMask), _mm_and_ps(signMask, negativeOneToPower) ), cVal);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

cPtr += 4;

}

__m128 aVal1, aVal2, aVal3, aVal4;

__m128 cVal1, cVal2, cVal3, cVal4;

for(;number < sixteenthPoints; number++) {

cVal1 = _mm_dp_ps(aVal1, aVal1, 0xF1);

aVal2 = _mm_load_ps(aPtr); aPtr += 4;

squareAccumulator = _mm_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2

}

returnValue = squareBuffer[0];

returnValue += squareBuffer[1];

returnValue += squareBuffer[2];

returnValue += squareBuffer[3];

number = sixteenthPoints * 16;

for(;number < num_points; number++){

returnValue += (*aPtr) * (*aPtr);

squareAccumulator = _mm_add_ps(squareAccumulator, aVal);

aPtr += 4;

}

returnValue = squareBuffer[0];

returnValue += squareBuffer[1];

returnValue += squareBuffer[2];

returnValue += squareBuffer[3];

number = quarterPoints * 4;

for(;number < num_points; number++){

returnValue += (*aPtr) * (*aPtr);

if(num_points > 0){

const float* aPtr = inputBuffer;

unsigned int number = 0;

for(number = 0; number < num_points; number++){

returnValue += (*aPtr) * (*aPtr);

aPtr++;

__m128 aVal, cVal;

for(;number < quarterPoints; number++){

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m128 aVal1, aVal2, aVal3, aVal4;

__m128 cVal1, cVal2, cVal3, cVal4;

for(;number < sixteenthPoints; number++) {

cVal1 = _mm_dp_ps(aVal1, aVal1, 0xF1);

accumulator = _mm_add_ps(accumulator, aVal1); // accumulator += x

squareAccumulator = _mm_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2

}

_mm_store_ps(meanBuffer,accumulator); // Store the results back into the C container

newMean = meanBuffer[0];

newMean += meanBuffer[1];

newMean += meanBuffer[2];

returnValue += squareBuffer[1];

returnValue += squareBuffer[2];

returnValue += squareBuffer[3];

number = sixteenthPoints * 16;

for(;number < num_points; number++){

returnValue += (*aPtr) * (*aPtr);

aPtr += 4;

}

_mm_store_ps(meanBuffer,accumulator); // Store the results back into the C container

newMean = meanBuffer[0];

newMean += meanBuffer[1];

newMean += meanBuffer[2];

returnValue += squareBuffer[1];

returnValue += squareBuffer[2];

returnValue += squareBuffer[3];

number = quarterPoints * 4;

for(;number < num_points; number++){

returnValue += (*aPtr) * (*aPtr);

if(num_points > 0){

const float* aPtr = inputBuffer;

unsigned int number = 0;

for(number = 0; number < num_points; number++){

returnValue += (*aPtr) * (*aPtr);

newMean += *aPtr++;

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_loadu_ps(bPtr);

_mm_storeu_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

for(number = 0; number < num_points; number++){

dotProduct += ((*aPtr++) * (*bPtr++));

}

*result = dotProduct;

}

static inline void volk_32f_x2_dot_prod_32f_a_sse( float* result, const float* input, const float* taps, unsigned int num_points) {

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

__m128 dotProdVal = _mm_setzero_ps();

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

dotProdVal = _mm_add_ps(cVal, dotProdVal);

}

*result = dotProduct;

}

#ifdef LV_HAVE_SSE3

__m128 dotProdVal = _mm_setzero_ps();

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

dotProdVal = _mm_hadd_ps(dotProdVal, cVal);

}

*result = dotProduct;

#endif /*LV_HAVE_SSE3*/

__m128 dotProdVal = _mm_setzero_ps();

aVal1 = _mm_load_ps(aPtr); aPtr += 4;

aVal2 = _mm_load_ps(aPtr); aPtr += 4;

bVal2 = _mm_load_ps(bPtr); bPtr += 4;

bVal3 = _mm_load_ps(bPtr); bPtr += 4;

bVal4 = _mm_load_ps(bPtr); bPtr += 4;

cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);

cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);

cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);

}

*result = dotProduct;

#endif /*LV_HAVE_SSE4_1*/

for(number = 0; number < num_points; number++){

dotProduct += ((*aPtr++) * (*bPtr++));

}

*result = dotProduct;

}

static inline void volk_32f_x2_dot_prod_32f_u_sse( float* result, const float* input, const float* taps, unsigned int num_points) {

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

__m128 dotProdVal = _mm_setzero_ps();

for(;number < quarterPoints; number++){

bVal = _mm_loadu_ps(bPtr);

dotProdVal = _mm_add_ps(cVal, dotProdVal);

}

*result = dotProduct;

}

#ifdef LV_HAVE_SSE3

__m128 dotProdVal = _mm_setzero_ps();

for(;number < quarterPoints; number++){

bVal = _mm_loadu_ps(bPtr);

dotProdVal = _mm_hadd_ps(dotProdVal, cVal);

}

*result = dotProduct;

#endif /*LV_HAVE_SSE3*/

__m128 dotProdVal = _mm_setzero_ps();

for(;number < sixteenthPoints; number++){

aVal1 = _mm_loadu_ps(aPtr); aPtr += 4;

aVal2 = _mm_loadu_ps(aPtr); aPtr += 4;

aVal3 = _mm_loadu_ps(aPtr); aPtr += 4;

bVal2 = _mm_loadu_ps(bPtr); bPtr += 4;

bVal3 = _mm_loadu_ps(bPtr); bPtr += 4;

bVal4 = _mm_loadu_ps(bPtr); bPtr += 4;

cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);

cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);

cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);

}

*result = dotProduct;

#endif /*LV_HAVE_SSE4_1*/

const float* qBufferPtr = qBuffer;

const uint64_t quarterPoints = num_points / 4;

__m128 iValue, qValue, cplxValue;

for(;number < quarterPoints; number++){

iValue = _mm_load_ps(iBufferPtr);

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m256 aVal, bVal, cVal;

for(;number < eighthPoints; number++){

bVal = _mm256_load_ps(bPtr);

_mm256_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 8;

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_loadu_ps(bPtr);

_mm_storeu_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m256 aVal, bVal, cVal;

for(;number < eighthPoints; number++){

bVal = _mm256_loadu_ps(bPtr);

_mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 8;

__m128 vScalar = _mm_set_ps1(scalar);

const unsigned int quarterPoints = num_points / 4;

__m128 iValue, qValue, cplxValue1, cplxValue2;

__m128i intValue1, intValue2;

*complexVectorPtr++ = (int16_t)(*iBufferPtr++ * scalar);

*complexVectorPtr++ = (int16_t)(*qBufferPtr++ * scalar);

}

}

#endif /* LV_HAVE_SSE2 */

__m128 vScalar = _mm_set_ps1(scalar);

const unsigned int quarterPoints = num_points / 4;

__m128 iValue, qValue, cplxValue;

int16_t* complexVectorPtr = (int16_t*)complexVector;

// Interleaves the upper two values in the i and q variables into one buffer

cplxValue = _mm_unpackhi_ps(iValue, qValue);

cplxValue = _mm_mul_ps(cplxValue, vScalar);

_mm_store_ps(floatBuffer, cplxValue);

*complexVectorPtr++ = (int16_t)(floatBuffer[0]);

*complexVectorPtr++ = (int16_t)(floatBuffer[1]);

*complexVectorPtr++ = (int16_t)(floatBuffer[2]);

*complexVectorPtr++ = (int16_t)(*iBufferPtr++ * scalar);

*complexVectorPtr++ = (int16_t)(*qBufferPtr++ * scalar);

}

}

#endif /* LV_HAVE_SSE */

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

#include<pmmintrin.h>

static inline void volk_32f_x3_sum_of_poly_32f_a_sse3(float* target, float* src0, float* center_point_array, float* cutoff, unsigned int num_bytes) {

float result = 0.0;

float fst = 0.0;

float sq = 0.0;

float thrd = 0.0;

float frth = 0.0;

//float fith = 0.0;

__m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10;// xmm11, xmm12;

xmm9 = _mm_setzero_ps();

xmm1 = _mm_setzero_ps();

xmm0 = _mm_load1_ps(&center_point_array[0]);

xmm6 = _mm_load1_ps(&center_point_array[1]);

xmm7 = _mm_load1_ps(&center_point_array[2]);

xmm8 = _mm_load1_ps(&center_point_array[3]);

//xmm11 = _mm_load1_ps(&center_point_array[4]);

xmm10 = _mm_load1_ps(cutoff);

int bound = num_bytes >> 4;

int leftovers = (num_bytes >> 2) & 3;

int i = 0;

for(; i < bound; ++i) {

xmm2 = _mm_load_ps(src0);

xmm2 = _mm_max_ps(xmm10, xmm2);

xmm2 = _mm_add_ps(xmm2, xmm3);

xmm3 = _mm_add_ps(xmm4, xmm5);

src0 += 4;

xmm9 = _mm_add_ps(xmm2, xmm9);

xmm1 = _mm_add_ps(xmm3, xmm1);

//xmm9 = _mm_add_ps(xmm12, xmm9);

}

xmm2 = _mm_hadd_ps(xmm9, xmm1);

xmm3 = _mm_hadd_ps(xmm2, xmm2);

xmm4 = _mm_hadd_ps(xmm3, xmm3);

_mm_store_ss(&result, xmm4);

for(i = 0; i < leftovers; ++i) {

fst = src0[i];

thrd = fst * sq;

frth = sq * sq;

//fith = sq * thrd;

//center_point_array[4] * fith);

}

target[0] = result;

}

#endif /*LV_HAVE_SSE3*/

static inline void volk_32f_x3_sum_of_poly_32f_a_generic(float* target, float* src0, float* center_point_array, float* cutoff, unsigned int num_bytes) {

float result = 0.0;

float fst = 0.0;

float sq = 0.0;

float thrd = 0.0;

float frth = 0.0;

//float fith = 0.0;

for(; i < num_bytes >> 2; ++i) {

fst = src0[i];

fst = MAX(fst, *cutoff);

sq = fst * fst;

thrd = fst * sq;

frth = sq * sq;

//fith = sq * thrd;

center_point_array[3] * frth); //+

//center_point_array[4] * fith);

center_point_array[3] * frth) +

(center_point_array[4]), i);

*/

}

result += ((float)(num_bytes >> 2)) * (center_point_array[4]);//(center_point_array[5]);

*target = result;

}

__m128 aVal1, aVal2, bVal, bVal1, bVal2, cVal;

for(;number < quarterPoints; number++){

aVal1 = _mm_load_ps((const float*)aPtr);

aPtr += 2;

aPtr += 2;

bVal = _mm_load_ps(bPtr);

bVal1 = _mm_shuffle_ps(bVal, bVal, _MM_SHUFFLE(1,1,0,0));

bVal2 = _mm_shuffle_ps(bVal, bVal, _MM_SHUFFLE(3,3,2,2));

_mm_store_ps((float*)cPtr,cVal); // Store the results back into the C container

cPtr += 2;

_mm_store_ps((float*)cPtr,cVal); // Store the results back into the C container

cPtr += 2;

const lv_32fc_t* aPtr = aVector;

const float* bPtr= bVector;

unsigned int number = 0;

for(number = 0; number < num_points; number++){

*cPtr++ = (*aPtr++) * (*bPtr++);

}

__m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);

for(;number < halfPoints; number++){

x = _mm_load_ps((float*)a); // Load the complex data as ar,ai,br,bi

x = _mm_xor_ps(x, conjugator); // conjugate register

_mm_store_ps((float*)c,x); // Store the results back into the C container

a += 2;

__m128 x;

lv_32fc_t* c = cVector;

const lv_32fc_t* a = aVector;

__m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);

for(;number < halfPoints; number++){

x = _mm_loadu_ps((float*)a); // Load the complex data as ar,ai,br,bi

x = _mm_xor_ps(x, conjugator); // conjugate register

_mm_storeu_ps((float*)c,x); // Store the results back into the C container

float* qBufferPtr = qBuffer;

unsigned int number = 0;

__m128 cplxValue1, cplxValue2, iValue, qValue;

for(;number < quarterPoints; number++){

cplxValue1 = _mm_load_ps(complexVectorPtr);

complexVectorPtr += 4;

double* iBufferPtr = iBuffer;

double* qBufferPtr = qBuffer;

__m128 cplxValue, fVal;

__m128d dVal;

for(;number < halfPoints; number++){

cplxValue = _mm_load_ps(complexVectorPtr);

complexVectorPtr += 4;

// Arrange in i1i2i1i2 format

fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2,0,2,0));

_mm_store_pd(iBufferPtr, dVal);

// Arrange in q1q2q1q2 format

fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3,1,3,1));

_mm_store_pd(qBufferPtr, dVal);

iBufferPtr += 2;

__m128 cplxValue1, cplxValue2, iValue;

for(;number < quarterPoints; number++){

cplxValue1 = _mm_load_ps(complexVectorPtr);

complexVectorPtr += 4;

__m128 cplxValue1, cplxValue2, iValue;

for(;number < quarterPoints; number++){

cplxValue1 = _mm_load_ps(complexVectorPtr);

complexVectorPtr += 4;

const float* complexVectorPtr = (float*)complexVector;

double* iBufferPtr = iBuffer;

__m128 cplxValue, fVal;

__m128d dVal;

for(;number < halfPoints; number++){

cplxValue = _mm_load_ps(complexVectorPtr);

complexVectorPtr += 4;

// Arrange in i1i2i1i2 format

fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2,0,2,0));

_mm_store_pd(iBufferPtr, dVal);

iBufferPtr += 2;

static inline void volk_32fc_index_max_16u_a_sse3(unsigned int* target, lv_32fc_t* src0, unsigned int num_bytes) {

union bit128 holderf;

union bit128 holderi;

float sq_dist = 0.0;

union bit128 xmm5, xmm4;

__m128 xmm1, xmm2, xmm3;

__m128i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;

xmm4.int_vec = xmmfour = _mm_setzero_si128();

holderf.int_vec = holder0 = _mm_setzero_si128();

holderi.int_vec = holder1 = _mm_setzero_si128();

int bound = num_bytes >> 5;

int leftovers0 = (num_bytes >> 4) & 1;

int leftovers1 = (num_bytes >> 3) & 1;

int i = 0;

xmm8 = _mm_set_epi32(3, 2, 1, 0);//remember the crazy reverse order!

xmm9 = xmm8 = _mm_setzero_si128();

xmm10 = _mm_set_epi32(4, 4, 4, 4);

xmm3 = _mm_setzero_ps();

;

//printf("%f, %f, %f, %f\n", ((float*)&xmm10)[0], ((float*)&xmm10)[1], ((float*)&xmm10)[2], ((float*)&xmm10)[3]);

for(; i < bound; ++i) {

xmm1 = _mm_load_ps((float*)src0);

xmm2 = _mm_load_ps((float*)&src0[2]);

src0 += 4;

xmm1 = _mm_mul_ps(xmm1, xmm1);

xmm2 = _mm_mul_ps(xmm2, xmm2);

xmm1 = _mm_hadd_ps(xmm1, xmm2);

xmm3 = _mm_max_ps(xmm1, xmm3);

xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);

xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);

xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);

xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);

xmm9 = _mm_add_epi32(xmm11, xmm12);

//printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1], ((float*)&xmm3)[2], ((float*)&xmm3)[3]);

//printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm10)[0], ((uint32_t*)&xmm10)[1], ((uint32_t*)&xmm10)[2], ((uint32_t*)&xmm10)[3]);

}

for(i = 0; i < leftovers0; ++i) {

xmm2 = _mm_load_ps((float*)src0);

xmm1 = _mm_movelh_ps(bit128_p(&xmm8)->float_vec, bit128_p(&xmm8)->float_vec);

xmm8 = bit128_p(&xmm1)->int_vec;

xmm3 = _mm_max_ps(xmm1, xmm3);

xmm10 = _mm_set_epi32(2, 2, 2, 2);//load1_ps((float*)&init[2]);

xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);

xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);

xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);

xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);

xmm9 = _mm_add_epi32(xmm11, xmm12);

//printf("egads%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);

}

for(i = 0; i < leftovers1; ++i) {

//printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);

sq_dist = lv_creal(src0[0]) * lv_creal(src0[0]) + lv_cimag(src0[0]) * lv_cimag(src0[0]);

xmm2 = _mm_load1_ps(&sq_dist);

xmm1 = xmm3;

xmm3 = _mm_max_ss(xmm3, xmm2);

xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);

xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);

xmm11 = _mm_and_si128(xmm8, xmm4.int_vec);

xmm12 = _mm_and_si128(xmm9, xmm5.int_vec);

xmm9 = _mm_add_epi32(xmm11, xmm12);

}

//printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1], ((float*)&xmm3)[2], ((float*)&xmm3)[3]);

//printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);

_mm_store_ps((float*)&(holderf.f), xmm3);

_mm_store_si128(&(holderi.int_vec), xmm9);

target[0] = holderi.i[0];

target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];

sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;

target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];

target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];

sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;

/*

float placeholder = 0.0;

unsigned int g0 = (((float*)&xmm3)[0] > ((float*)&xmm3)[1]);

unsigned int l0 = g0 ^ 1;

unsigned int g1 = (((float*)&xmm3)[1] > ((float*)&xmm3)[2]);

unsigned int l1 = g1 ^ 1;

temp0 = g0 * ((uint32_t*)&xmm9)[0] + l0 * ((uint32_t*)&xmm9)[1];

temp1 = g0 * ((uint32_t*)&xmm9)[2] + l0 * ((uint32_t*)&xmm9)[3];

placeholder = g0 * ((float*)&xmm3)[2] + l0 * ((float*)&xmm3)[3];

g0 = (sq_dist > placeholder);

l0 = g0 ^ 1;

target[0] = g0 * temp0 + l0 * temp1;

*/

}

#endif /*LV_HAVE_SSE3*/

float sq_dist = 0.0;

float max = 0.0;

unsigned int index = 0;

for(; i < num_bytes >> 3; ++i) {

sq_dist = lv_creal(src0[i]) * lv_creal(src0[i]) + lv_cimag(src0[i]) * lv_cimag(src0[i]);

index = sq_dist > max ? i : index;

max = sq_dist > max ? sq_dist : max;

}

target[0] = index;

}

#endif /*LV_HAVE_GENERIC*/

static inline void volk_32fc_magnitude_32f_a_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* complexVectorPtr = (float*)complexVector;

float* magnitudeVectorPtr = magnitudeVector;

static inline void volk_32fc_magnitude_32f_u_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* complexVectorPtr = (float*)complexVector;

float* magnitudeVectorPtr = magnitudeVector;

static inline void volk_32fc_magnitude_squared_32f_a_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* complexVectorPtr = (float*)complexVector;

float* magnitudeVectorPtr = magnitudeVector;

static inline void volk_32fc_magnitude_squared_32f_u_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const float* complexVectorPtr = (float*)complexVector;

float* magnitudeVectorPtr = magnitudeVector;

const float invNormalizeFactor = 1.0 / normalizeFactor;

#ifdef LV_HAVE_LIB_SIMDMATH

__m128 testVector = _mm_set_ps1(2*M_PI);

__m128 correctVector = _mm_set_ps1(M_PI);

__m128 vNormalizeFactor = _mm_set_ps1(invNormalizeFactor);

__m128 phase;

__m128 complex1, complex2, iValue, qValue;

__m128 keepMask;

for (; number < quarterPoints; number++) {

// Load IQ data:

complex1 = _mm_load_ps(complexVectorPtr);

complex2 = _mm_load_ps(complexVectorPtr);

complexVectorPtr += 4;

// Deinterleave IQ data:

// Arctan to get phase:

phase = atan2f4(qValue, iValue);

// When Q = 0 and I < 0, atan2f4 sucks and returns 2pi vice pi.

// Compare to 2pi:

keepMask = _mm_cmpneq_ps(phase,testVector);

phase = _mm_blendv_ps(correctVector, phase, keepMask);

phase = _mm_mul_ps(phase, vNormalizeFactor);

_mm_store_ps((float*)outPtr, phase);

outPtr += 4;

const float invNormalizeFactor = 1.0 / normalizeFactor;

#ifdef LV_HAVE_LIB_SIMDMATH

__m128 testVector = _mm_set_ps1(2*M_PI);

__m128 correctVector = _mm_set_ps1(M_PI);

__m128 vNormalizeFactor = _mm_set_ps1(invNormalizeFactor);

__m128 complex1, complex2, iValue, qValue;

__m128 mask;

__m128 keepMask;

for (; number < quarterPoints; number++) {

// Load IQ data:

complex1 = _mm_load_ps(complexVectorPtr);

complex2 = _mm_load_ps(complexVectorPtr);

complexVectorPtr += 4;

// Deinterleave IQ data:

// Arctan to get phase:

phase = atan2f4(qValue, iValue);

// When Q = 0 and I < 0, atan2f4 sucks and returns 2pi vice pi.

phase = _mm_and_ps(phase, keepMask);

mask = _mm_andnot_ps(keepMask, correctVector);

phase = _mm_or_ps(phase, mask);

phase = _mm_mul_ps(phase, vNormalizeFactor);

_mm_store_ps((float*)outPtr, phase);

outPtr += 4;

*/

static inline void volk_32fc_s32f_power_32fc_a_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float power, unsigned int num_points){

unsigned int number = 0;

lv_32fc_t* cPtr = cVector;

const lv_32fc_t* aPtr = aVector;

#ifdef LV_HAVE_LIB_SIMDMATH

const unsigned int quarterPoints = num_points / 4;

__m128 vPower = _mm_set_ps1(power);

__m128 cplxValue1, cplxValue2, magnitude, phase, iValue, qValue;

for(;number < quarterPoints; number++){

aPtr += 2;

aPtr += 2;

// Convert to polar coordinates

// Arrange in i1i2i3i4 format

iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));

// Arrange in q1q2q3q4 format

qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));

phase = atan2f4(qValue, iValue); // Calculate the Phase

magnitude = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(iValue, iValue), _mm_mul_ps(qValue, qValue))); // Calculate the magnitude by square rooting the added I2 and Q2 values

// Now calculate the power of the polar coordinate data

magnitude = powf4(magnitude, vPower); // Take the magnitude to the specified power

phase = _mm_mul_ps(phase, vPower); // Multiply the phase by the specified power

// Convert back to cartesian coordinates

iValue = _mm_mul_ps( cosf4(phase), magnitude); // Multiply the cos of the phase by the magnitude

qValue = _mm_mul_ps( sinf4(phase), magnitude); // Multiply the sin of the phase by the magnitude

cplxValue1 = _mm_unpacklo_ps(iValue, qValue); // Interleave the lower two i & q values

cplxValue2 = _mm_unpackhi_ps(iValue, qValue); // Interleave the upper two i & q values

_mm_store_ps((float*)cPtr,cplxValue1); // Store the results back into the C container

cPtr += 2;

_mm_store_ps((float*)cPtr,cplxValue2); // Store the results back into the C container

cPtr += 2;

}

number = quarterPoints * 4;

#endif /* LV_HAVE_LIB_SIMDMATH */

__m128 input1, input2;

const uint64_t quarterPoints = num_points / 4;

for(;number < quarterPoints; number++){

input1 =_mm_load_ps(inputPtr);

inputPtr += 4;

input2 =_mm_load_ps(inputPtr);

// Apply the normalization factor

input1 = _mm_mul_ps(input1, invNormalizationFactor);

input2 = _mm_mul_ps(input2, invNormalizationFactor);

// Multiply each value by itself

// (r1*r1), (i1*i1), (r2*r2), (i2*i2)

input1 = _mm_mul_ps(input1, input1);

// (r3*r3), (i3*i3), (r4*r4), (i4*i4)

input2 = _mm_mul_ps(input2, input2);

// Horizontal add, to add (r*r) + (i*i) for each complex value

// (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)

power = _mm_hadd_ps(input1, input2);

// Calculate the natural log power

power = logf4(power);

// Convert to log10 and multiply by 10.0

power = _mm_mul_ps(power, magScalar);

// Store the floating point results

_mm_store_ps(destPtr, power);

destPtr += 4;

}

#endif /* LV_HAVE_LIB_SIMDMATH */

// Calculate the FFT for any remaining points

const float imag = *inputPtr++ * iNormalizationFactor;

*destPtr = 10.0*log10f(((real * real) + (imag * imag)) + 1e-20);

destPtr++;

}

}

#endif /* LV_HAVE_SSE3 */

*realFFTDataPointsPtr = 10.0*log10f(((real * real) + (imag * imag)) + 1e-20);

realFFTDataPointsPtr++;

}

}

magScalar = _mm_div_ps(magScalar, logf4(magScalar));

__m128 invRBW = _mm_set_ps1(iRBW);

__m128 invNormalizationFactor = _mm_set_ps1(iNormalizationFactor);

__m128 power;

__m128 input1, input2;

const uint64_t quarterPoints = num_points / 4;

for(;number < quarterPoints; number++){

input1 =_mm_load_ps(inputPtr);

inputPtr += 4;

input2 =_mm_load_ps(inputPtr);

inputPtr += 4;

// Apply the normalization factor

input1 = _mm_mul_ps(input1, invNormalizationFactor);

input2 = _mm_mul_ps(input2, invNormalizationFactor);

input1 = _mm_mul_ps(input1, input1);

// (r3*r3), (i3*i3), (r4*r4), (i4*i4)

input2 = _mm_mul_ps(input2, input2);

// Horizontal add, to add (r*r) + (i*i) for each complex value

// (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)

power = _mm_hadd_ps(input1, input2);

// Calculate the natural log power

power = logf4(power);

// Convert to log10 and multiply by 10.0

power = _mm_mul_ps(power, magScalar);

// Store the floating point results

_mm_store_ps(destPtr, power);

destPtr += 4;

}

#endif /* LV_HAVE_LIB_SIMDMATH */

// Calculate the FFT for any remaining points

for(; number < num_points; number++){

// 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)

// 75 ohm load assumption

// 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)

const float real = *inputPtr++ * iNormalizationFactor;

const float imag = *inputPtr++ * iNormalizationFactor;

*destPtr = 10.0*log10f((((real * real) + (imag * imag)) + 1e-20) * iRBW);

destPtr++;

}

}

#endif /* LV_HAVE_SSE3 */

const float imag = *inputPtr++ * iNormalizationFactor;

*realFFTDataPointsPtr = 10.0*log10f((((real * real) + (imag * imag)) + 1e-20) * invRBW);

realFFTDataPointsPtr++;

}

}

yh = _mm_set_ps1(lv_cimag(scalar));

for(;number < halfPoints; number++){

x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

_mm_store_ps((float*)c,z); // Store the results back into the C container

a += 2;

yh = _mm_set_ps1(lv_cimag(scalar));

for(;number < halfPoints; number++){

x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

_mm_storeu_ps((float*)c,z); // Store the results back into the C container

a += 2;

static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

float * res = (float*) result;

float * in = (float*) input;

float * tp = (float*) taps;

unsigned int n_2_ccomplex_blocks = num_bytes >> 4;

unsigned int isodd = (num_bytes >> 3) &1;

float sum0[2] = {0,0};

float sum1[2] = {0,0};

unsigned int i = 0;

for(i = 0; i < n_2_ccomplex_blocks; ++i) {

sum0[0] += in[0] * tp[0] + in[1] * tp[1];

sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];

sum1[0] += in[2] * tp[2] + in[3] * tp[3];

sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];

in += 4;

tp += 4;

}

res[0] = sum0[0] + sum1[0];

res[1] = sum0[1] + sum1[1];

for(i = 0; i < isodd; ++i) {

static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

__VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};

(

"# ccomplex_conjugate_dotprod_generic (float* result, const float *input,\n\t"

"# const float *taps, unsigned num_bytes)\n\t"

:[rsi] "r" (input), [rdx] "r" (taps), "c" (num_bytes), [rdi] "r" (result), [conjugator] "r" (conjugator)

:"rax", "r8", "r9", "r10"

);

int getem = num_bytes % 16;

for(; getem > 0; getem -= 8) {

*result += (input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]));

}

return;

#endif

#if LV_HAVE_SSE && LV_HAVE_32

static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

__VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};

int bound = num_bytes >> 4;

int leftovers = num_bytes % 16;

(

" #pushl %%ebp\n\t"

" #movl %%esp, %%ebp\n\t"

" movaps 0(%[edx]), %%xmm2\n\t"

" movl %[ecx], (%[out])\n\t"

" shrl $5, %[ecx] # ecx = n_2_ccomplex_blocks / 2\n\t"

" xorps %%xmm1, %%xmm2\n\t"

" jmp .%=L1_test\n\t"

" # 4 taps / loop\n\t"

: [eax] "r" (input), [edx] "r" (taps), [ecx] "r" (num_bytes), [out] "r" (result), [conjugator] "r" (conjugator)

);

printf("%d, %d\n", leftovers, bound);

for(; leftovers > 0; leftovers -= 8) {

*result += (input[(bound << 1)] * lv_conj(taps[(bound << 1)]));

}

return;

}

static inline void volk_32fc_x2_conjugate_dot_prod_32fc_u_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

float * res = (float*) result;

float * in = (float*) input;

float * tp = (float*) taps;

unsigned int n_2_ccomplex_blocks = num_bytes >> 4;

unsigned int isodd = (num_bytes >> 3) &1;

float sum0[2] = {0,0};

float sum1[2] = {0,0};

unsigned int i = 0;

for(i = 0; i < n_2_ccomplex_blocks; ++i) {

sum0[0] += in[0] * tp[0] + in[1] * tp[1];

sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];

sum1[0] += in[2] * tp[2] + in[3] * tp[3];

sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];

in += 4;

tp += 4;

}

res[0] = sum0[0] + sum1[0];

res[1] = sum0[1] + sum1[1];

for(i = 0; i < isodd; ++i) {

uint32_t intRep[4];

__m128 vec;

} halfMask;

union NegMask {

int intRep[4];

__m128 vec;

__m128 in1, in2, Rv, fehg, Iv, Rs, Ivm, Is;

__m128 zv = {0,0,0,0};

halfMask.intRep[0] = halfMask.intRep[1] = 0xFFFFFFFF;

halfMask.intRep[2] = halfMask.intRep[3] = 0x00000000;

negMask.intRep[0] = negMask.intRep[2] = 0x80000000;

negMask.intRep[1] = negMask.intRep[3] = 0;

// main loop

while(num_bytes >= 4*sizeof(float)){

#include <string.h>

static inline void volk_32fc_x2_dot_prod_32fc_a_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

float * res = (float*) result;

float * in = (float*) input;

float * tp = (float*) taps;

unsigned int n_2_ccomplex_blocks = num_bytes >> 4;

unsigned int isodd = (num_bytes >> 3) &1;

float sum0[2] = {0,0};

float sum1[2] = {0,0};

unsigned int i = 0;

for(i = 0; i < n_2_ccomplex_blocks; ++i) {

sum0[0] += in[0] * tp[0] - in[1] * tp[1];

sum0[1] += in[0] * tp[1] + in[1] * tp[0];

sum1[0] += in[2] * tp[2] - in[3] * tp[3];

sum1[1] += in[2] * tp[3] + in[3] * tp[2];

in += 4;

tp += 4;

}

res[0] = sum0[0] + sum1[0];

res[1] = sum0[1] + sum1[1];

for(i = 0; i < isodd; ++i) {

static inline void volk_32fc_x2_dot_prod_32fc_a_sse_64(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

(

"# ccomplex_dotprod_generic (float* result, const float *input,\n\t"

"# const float *taps, unsigned num_bytes)\n\t"

:[rsi] "r" (input), [rdx] "r" (taps), "c" (num_bytes), [rdi] "r" (result)

:"rax", "r8", "r9", "r10"

);

int getem = num_bytes % 16;

for(; getem > 0; getem -= 8) {

*result += (input[(num_bytes >> 3) - 1] * taps[(num_bytes >> 3) - 1]);

}

return;

}

#endif

volk_32fc_x2_dot_prod_32fc_a_generic(result, input, taps, num_bytes);

#if 0

(

" #pushl %%ebp\n\t"

" #movl %%esp, %%ebp\n\t"

: "eax", "ecx", "edx"

);

int getem = num_bytes % 16;

for(; getem > 0; getem -= 8) {

*result += (input[(num_bytes >> 3) - 1] * taps[(num_bytes >> 3) - 1]);

}

return;

}

#ifdef LV_HAVE_SSE3

#include <pmmintrin.h>

static inline void volk_32fc_x2_dot_prod_32fc_a_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

lv_32fc_t dotProduct;

memset(&dotProduct, 0x0, 2*sizeof(float));

dotProdVal = _mm_setzero_ps();

for(;number < halfPoints; number++){

x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

dotProdVal = _mm_add_ps(dotProdVal, z); // Add the complex multiplication results together

}

*result = dotProduct;

#endif /*LV_HAVE_SSE3*/

static inline void volk_32fc_x2_dot_prod_32fc_a_sse4_1(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {

volk_32fc_x2_dot_prod_32fc_a_sse3(result, input, taps, num_bytes);

// SSE3 version runs twice as fast as the SSE4.1 version, so turning off SSE4 version for now

__m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, real0, real1, im0, im1;

float *p_input, *p_taps;

__m64 *p_result;

static const __m128i neg = {0x000000000000000080000000};

int i = 0;

int bound = (num_bytes >> 5);

int leftovers = (num_bytes & 24) >> 3;

real1 = _mm_sub_ps(real1, real1);

im0 = _mm_sub_ps(im0, im0);

im1 = _mm_sub_ps(im1, im1);

for(; i < bound; ++i) {

xmm0 = _mm_load_ps(p_input);

xmm1 = _mm_load_ps(p_taps);

p_input += 4;

p_taps += 4;

xmm2 = _mm_load_ps(p_input);

xmm3 = _mm_load_ps(p_taps);

p_input += 4;

p_taps += 4;

xmm4 = _mm_unpackhi_ps(xmm0, xmm2);

xmm5 = _mm_unpackhi_ps(xmm1, xmm3);

xmm0 = _mm_unpacklo_ps(xmm0, xmm2);

xmm2 = _mm_unpacklo_ps(xmm1, xmm3);

//imaginary vector from input

xmm1 = _mm_unpackhi_ps(xmm0, xmm4);

//real vector from input

xmm0 = _mm_unpackhi_ps(xmm2, xmm5);

//real vector from taps

xmm2 = _mm_unpacklo_ps(xmm2, xmm5);

xmm4 = _mm_dp_ps(xmm3, xmm2, 0xf1);

xmm5 = _mm_dp_ps(xmm1, xmm0, 0xf1);

xmm6 = _mm_dp_ps(xmm3, xmm0, 0xf2);

xmm7 = _mm_dp_ps(xmm1, xmm2, 0xf2);

real0 = _mm_add_ps(xmm4, real0);

real1 = _mm_add_ps(xmm5, real1);

im0 = _mm_add_ps(xmm6, im0);

im1 = _mm_add_ps(xmm7, im1);

}

real1 = _mm_xor_ps(real1, (__m128)neg);

im0 = _mm_add_ps(im0, im1);

real0 = _mm_add_ps(real0, real1);

im0 = _mm_add_ps(im0, real0);

_mm_storel_pi(p_result, im0);

for(i = bound * 4; i < (bound * 4) + leftovers; ++i) {

*result += input[i] * taps[i];

}

*/

#endif /*LV_HAVE_SSE4_1*/

const lv_32fc_t* a = aVector;

const lv_32fc_t* b = bVector;

for(;number < halfPoints; number++){

x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

_mm_store_ps((float*)c,z); // Store the results back into the C container

a += 2;

const lv_32fc_t* b = bVector;

for(;number < halfPoints; number++){

x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

_mm_storeu_ps((float*)c,z); // Store the results back into the C container

a += 2;

__m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);

for(;number < halfPoints; number++){

x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

y = _mm_xor_ps(y, conjugator); // conjugate y

yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

_mm_store_ps((float*)c,z); // Store the results back into the C container

a += 2;

__m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);

for(;number < halfPoints; number++){

x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

y = _mm_xor_ps(y, conjugator); // conjugate y

yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

_mm_storeu_ps((float*)c,z); // Store the results back into the C container

a += 2;

#include<pmmintrin.h>

static inline void volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* points, float scalar, unsigned int num_bytes) {

__m128 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8;

int leftovers0 = (num_bytes >> 4) & 1;

int leftovers1 = (num_bytes >> 3) & 1;

int i = 0;

xmm1 = _mm_setzero_ps();

xmm2 = _mm_load_ps((float*)&points[0]);

xmm8 = _mm_load1_ps(&scalar);

xmm1 = _mm_movelh_ps(xmm1, xmm1);

xmm3 = _mm_load_ps((float*)&points[2]);

for(; i < bound - 1; ++i) {

xmm4 = _mm_sub_ps(xmm1, xmm2);

xmm5 = _mm_sub_ps(xmm1, xmm3);

points += 4;

xmm6 = _mm_mul_ps(xmm4, xmm4);

xmm7 = _mm_mul_ps(xmm5, xmm5);

xmm2 = _mm_load_ps((float*)&points[0]);

xmm4 = _mm_hadd_ps(xmm6, xmm7);

xmm3 = _mm_load_ps((float*)&points[2]);

xmm4 = _mm_mul_ps(xmm4, xmm8);

_mm_store_ps(target, xmm4);

target += 4;

}

xmm4 = _mm_sub_ps(xmm1, xmm2);

xmm5 = _mm_sub_ps(xmm1, xmm3);

points += 4;

xmm6 = _mm_mul_ps(xmm4, xmm4);

xmm7 = _mm_mul_ps(xmm5, xmm5);

xmm4 = _mm_hadd_ps(xmm6, xmm7);

xmm4 = _mm_mul_ps(xmm4, xmm8);

_mm_store_ps(target, xmm4);

target += 4;

for(i = 0; i < leftovers0; ++i) {

xmm2 = _mm_load_ps((float*)&points[0]);

xmm4 = _mm_sub_ps(xmm1, xmm2);

points += 2;

xmm6 = _mm_mul_ps(xmm4, xmm4);

xmm4 = _mm_hadd_ps(xmm6, xmm6);

xmm4 = _mm_mul_ps(xmm4, xmm8);

_mm_storeh_pi((__m64*)target, xmm4);

target += 2;

}

for(i = 0; i < leftovers1; ++i) {

diff = src0[0] - points[0];

sq_dist = scalar * (lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff));

static inline void volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_generic(float* target, lv_32fc_t* src0, lv_32fc_t* points, float scalar, unsigned int num_bytes) {

lv_32fc_t diff;

float sq_dist;

for(; i < num_bytes >> 3; ++i) {

diff = src0[0] - points[i];

sq_dist = scalar * (lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff));

target[i] = sq_dist;

}

}

#include<pmmintrin.h>

static inline void volk_32fc_x2_square_dist_32f_a_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_bytes) {

__m128 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;

int i = 0;

xmm1 = _mm_setzero_ps();

xmm2 = _mm_load_ps((float*)&points[0]);

xmm1 = _mm_movelh_ps(xmm1, xmm1);

xmm3 = _mm_load_ps((float*)&points[2]);

for(; i < bound - 1; ++i) {

xmm4 = _mm_sub_ps(xmm1, xmm2);

points += 4;

xmm6 = _mm_mul_ps(xmm4, xmm4);

xmm7 = _mm_mul_ps(xmm5, xmm5);

xmm2 = _mm_load_ps((float*)&points[0]);

xmm4 = _mm_hadd_ps(xmm6, xmm7);

xmm3 = _mm_load_ps((float*)&points[2]);

target += 4;

}

xmm4 = _mm_sub_ps(xmm1, xmm2);

xmm5 = _mm_sub_ps(xmm1, xmm3);

points += 4;

xmm6 = _mm_mul_ps(xmm4, xmm4);

xmm7 = _mm_mul_ps(xmm5, xmm5);

xmm4 = _mm_hadd_ps(xmm6, xmm7);

_mm_store_ps(target, xmm4);

target += 4;

for(i = 0; i < leftovers0; ++i) {

xmm2 = _mm_load_ps((float*)&points[0]);

xmm4 = _mm_sub_ps(xmm1, xmm2);

points += 2;

xmm6 = _mm_mul_ps(xmm4, xmm4);

xmm4 = _mm_hadd_ps(xmm6, xmm6);

_mm_storeh_pi((__m64*)target, xmm4);

target += 2;

}

for(i = 0; i < leftovers1; ++i) {

diff = src0[0] - points[0];

sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);

static inline void volk_32fc_x2_square_dist_32f_a_generic(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_bytes) {

lv_32fc_t diff;

float sq_dist;

for(; i < num_bytes >> 3; ++i) {

diff = src0[0] - points[i];

sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);

target[i] = sq_dist;

}

}

static inline void volk_32i_s32f_convert_32f_a_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

float* outputVectorPtr = outputVector;

const float iScalar = 1.0 / scalar;

__m128 invScalar = _mm_set_ps1(iScalar);

static inline void volk_32i_s32f_convert_32f_u_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

float* outputVectorPtr = outputVector;

const float iScalar = 1.0 / scalar;

__m128 invScalar = _mm_set_ps1(iScalar);

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

__m128 aVal, bVal, cVal;

for(;number < quarterPoints; number++){

bVal = _mm_load_ps(bPtr);

_mm_store_ps(cPtr,cVal); // Store the results back into the C container

aPtr += 4;

_mm_store_si128((__m128i*)inputPtr, output);

inputPtr += 4;

}

// Byteswap any remaining points:

for(; number < num_points; number++){

uint32_t outputVal = *inputPtr;

outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) | ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));

for(point = 0; point < num_points; point++){

uint32_t output = *inputPtr;

output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) | ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));

*inputPtr = output;

inputPtr++;

}

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const double* inputVectorPtr = (const double*)inputVector;

float* outputVectorPtr = outputVector;

__m128 ret, ret2;

for(;number < quarterPoints; number++){

inputVal1 = _mm_load_pd(inputVectorPtr); inputVectorPtr += 2;

inputVal2 = _mm_load_pd(inputVectorPtr); inputVectorPtr += 2;

ret = _mm_cvtpd_ps(inputVal1);

ret2 = _mm_cvtpd_ps(inputVal2);

outputVectorPtr += 4;

}

for(; number < num_points; number++){

outputVector[number] = (float)(inputVector[number]);

}

unsigned int number = 0;

const unsigned int quarterPoints = num_points / 4;

const double* inputVectorPtr = (const double*)inputVector;

float* outputVectorPtr = outputVector;

__m128 ret, ret2;

for(;number < quarterPoints; number++){

inputVal1 = _mm_loadu_pd(inputVectorPtr); inputVectorPtr += 2;

inputVal2 = _mm_loadu_pd(inputVectorPtr); inputVectorPtr += 2;

ret = _mm_cvtpd_ps(inputVal1);

ret2 = _mm_cvtpd_ps(inputVal2);

outputVectorPtr += 4;

}

for(; number < num_points; number++){

outputVector[number] = (float)(inputVector[number]);

}

__m128d aVal, bVal, cVal;

for(;number < halfPoints; number++){

bVal = _mm_load_pd(bPtr);

_mm_store_pd(cPtr,cVal); // Store the results back into the C container

aPtr += 2;

__m128d aVal, bVal, cVal;

for(;number < halfPoints; number++){

bVal = _mm_load_pd(bPtr);

_mm_store_pd(cPtr,cVal); // Store the results back into the C container

aPtr += 2;

output = _mm_or_si128(output, byte2);

byte3 = _mm_and_si128(byte3, byte3mask);

output = _mm_or_si128(output, byte3);

// Reorder the two words

output = _mm_shuffle_epi32(output, _MM_SHUFFLE(2, 3, 0, 1));

_mm_store_si128((__m128i*)inputPtr, output);

inputPtr += 4;

}

// Byteswap any remaining points:

for(; number < num_points; number++){

uint32_t output1 = *inputPtr;

uint32_t output2 = inputPtr[1];

output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));

output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));

*inputPtr++ = output2;

*inputPtr++ = output1;

}

for(point = 0; point < num_points; point++){

uint32_t output1 = *inputPtr;

uint32_t output2 = inputPtr[1];

output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));

output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));

*inputPtr++ = output2;

*inputPtr++ = output1;

}

static inline void volk_64u_popcnt_a_generic(uint64_t* ret, const uint64_t value) {

//const uint32_t* valueVector = (const uint32_t*)&value;

// This is faster than a lookup table

//uint32_t retVal = valueVector[0];

uint32_t retVal = (uint32_t)(value && 0x00000000FFFFFFFF);

static inline void volk_8i_s32f_convert_32f_a_sse4_1(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int sixteenthPoints = num_points / 16;

float* outputVectorPtr = outputVector;

const float iScalar = 1.0 / scalar;

__m128 invScalar = _mm_set_ps1(iScalar);

static inline void volk_8i_s32f_convert_32f_u_sse4_1(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){

unsigned int number = 0;

const unsigned int sixteenthPoints = num_points / 16;

float* outputVectorPtr = outputVector;

const float iScalar = 1.0 / scalar;

__m128 invScalar = _mm_set_ps1( iScalar );

float* qBufferPtr = qBuffer;

unsigned int number = 0;

__m128 iFloatValue, qFloatValue;

const float iScalar= 1.0 / scalar;

*iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;

*qBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;

}

}

#endif /* LV_HAVE_SSE4_1 */

float* qBufferPtr = qBuffer;

unsigned int number = 0;

__m128 cplxValue1, cplxValue2, iValue, qValue;

__m128 invScalar = _mm_set_ps1(1.0/scalar);

floatBuffer[1] = (float)(complexVectorPtr[1]);

floatBuffer[2] = (float)(complexVectorPtr[2]);

floatBuffer[3] = (float)(complexVectorPtr[3]);

floatBuffer[4] = (float)(complexVectorPtr[4]);

floatBuffer[5] = (float)(complexVectorPtr[5]);

floatBuffer[6] = (float)(complexVectorPtr[6]);

float* iBufferPtr = iBuffer;

unsigned int number = 0;

__m128 iFloatValue;

const float iScalar= 1.0 / scalar;

*iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;

complexVectorPtr++;

}

}

#endif /* LV_HAVE_SSE4_1 */

float* iBufferPtr = iBuffer;

unsigned int number = 0;

__m128 iValue;

const float iScalar= 1.0 / scalar;

floatBuffer[0] = (float)(*complexVectorPtr); complexVectorPtr += 2;

floatBuffer[1] = (float)(*complexVectorPtr); complexVectorPtr += 2;

floatBuffer[2] = (float)(*complexVectorPtr); complexVectorPtr += 2;

iValue = _mm_load_ps(floatBuffer);

*iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;

complexVectorPtr++;

}

}

#endif /* LV_HAVE_SSE */

const lv_8sc_t* a = aVector;

const lv_8sc_t* b = bVector;

__m128i conjugateSign = _mm_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1);

for(;number < quarterPoints; number++){

// Convert into 8 bit values into 16 bit values

x = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)a));

y = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)b));

// Calculate the ar*cr - ai*(-ci) portions

realz = _mm_madd_epi16(x,y);

// Calculate the complex conjugate of the cr + ci j values

y = _mm_sign_epi16(y, conjugateSign);

b += 4;

c += 4;

}

number = quarterPoints * 4;

int16_t* c16Ptr = (int16_t*)&cVector[number];

int8_t* a8Ptr = (int8_t*)&aVector[number];

float bImag = (float)*b8Ptr++;

lv_32fc_t bVal = lv_cmake( bReal, -bImag );

lv_32fc_t temp = aVal * bVal;

*cFloatPtr++ = lv_creal(temp) / scalar;

*cFloatPtr++ = lv_cimag(temp) / scalar;

}

float bImag = (float)*b8Ptr++;

lv_32fc_t bVal = lv_cmake( bReal, -bImag );

lv_32fc_t temp = aVal * bVal;

*cPtr++ = (lv_creal(temp) * invScalar);

*cPtr++ = (lv_cimag(temp) * invScalar);

}

* under the terms of the GNU General Public License as published by the

* Free Software Foundation; either version 3, or (at your option) any

* later version.

* This file 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.

* Under Section 7 of GPL version 3, you are granted additional

* permissions described in the GCC Runtime Library Exception, version

* 3.1, as published by the Free Software Foundation.

* You should have received a copy of the GNU General Public License and

* a copy of the GCC Runtime Library Exception along with this program;

* see the files COPYING3 and COPYING.RUNTIME respectively. If not, see

void qa_16s_add_quad_aligned16::t1() {

volk_environment_init();

clock_t start, end;

double total;

__VOLK_ATTR_ALIGNED(16) short input2[vlen];

__VOLK_ATTR_ALIGNED(16) short input3[vlen];

__VOLK_ATTR_ALIGNED(16) short input4[vlen];

__VOLK_ATTR_ALIGNED(16) short output0[vlen];

__VOLK_ATTR_ALIGNED(16) short output1[vlen];

__VOLK_ATTR_ALIGNED(16) short output2[vlen];

short minus3 = ((short) (rand() - (RAND_MAX/2))) >> 2;

short plus4 = ((short) (rand() - (RAND_MAX/2))) >> 2;

short minus4 = ((short) (rand() - (RAND_MAX/2))) >> 2;

input0[i] = plus0 - minus0;

input1[i] = plus1 - minus1;

input2[i] = plus2 - minus2;

input3[i] = plus3 - minus3;

input4[i] = plus4 - minus4;

}

printf("16s_add_quad_aligned\n");

//printf("inputs: %d, %d\n", input0[i*2], input0[i*2 + 1]);

//printf("generic... %d, ssse3... %d\n", output0[i], output1[i]);

}

for(int i = 0; i < vlen; ++i) {

//printf("%d...%d\n", output0[i], output01[i]);

CPPUNIT_ASSERT_EQUAL(output0[i], output01[i]);

static char permute2[16]__attribute__((aligned(16))) = {0x02, 0x03, 0x06, 0x07, 0x08, 0x09, 0x0c, 0x0d, 0x00, 0x01, 0x04, 0x05, 0x0a, 0x0b, 0x0e, 0x0f};

static char permute3[16]__attribute__((aligned(16))) = {0x00, 0x01, 0x04, 0x05, 0x0a, 0x0b, 0x0e, 0x0f, 0x02, 0x03, 0x06, 0x07, 0x08, 0x09, 0x0c, 0x0d};

static char* permuters[4] = {permute0, permute1, permute2, permute3};

unsigned int num_bytes = vlen << 1;

volk_environment_init();

clock_t start, end;

double total;

__VOLK_ATTR_ALIGNED(16) short target[vlen];

__VOLK_ATTR_ALIGNED(16) short target2[vlen];

__VOLK_ATTR_ALIGNED(16) short target3[vlen];

__VOLK_ATTR_ALIGNED(16) short src0[vlen];

__VOLK_ATTR_ALIGNED(16) short permute_indexes[vlen] = {

7, 5, 2, 0, 6, 4, 3, 1, 6, 4, 3, 1, 7, 5, 2, 0, 1, 3, 4, 6, 0, 2, 5, 7, 0, 2, 5, 7, 1, 3, 4, 6 };

__VOLK_ATTR_ALIGNED(16) short cntl3[vlen] = {

0xffff, 0xffff, 0x0000, 0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0xffff, 0xffff, 0xffff, 0xffff, 0x0000, 0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0xffff, 0xffff };

__VOLK_ATTR_ALIGNED(16) short scalars[4] = {1, 2, 3, 4};

for(int i = 0; i < vlen; ++i) {

src0[i] = i;

}

printf("16s_branch_4_state_8_aligned\n");

start = clock();

for(int i = 0; i < num_iters; ++i) {

volk_16s_permute_and_scalar_add_aligned16_manual(target, src0, permute_indexes, cntl0, cntl1, cntl2, cntl3, scalars, num_bytes, "sse2");

}

end = clock();

total = (double)(end-start)/(double)CLOCKS_PER_SEC;

printf("permute_and_scalar_add_time: %f\n", total);

start = clock();

for(int i = 0; i < num_iters; ++i) {

total = (double)(end-start)/(double)CLOCKS_PER_SEC;

printf("branch_4_state_8_time, ssse3: %f\n", total);

start = clock();

for(int i = 0; i < num_iters; ++i) {

volk_16s_branch_4_state_8_aligned16_manual(target3, src0, permuters, cntl2, cntl3, scalars, "generic");

}

end = clock();

total = (double)(end-start)/(double)CLOCKS_PER_SEC;

printf("permute_and_scalar_add_time, generic: %f\n", total);

for(int i = 0; i < vlen; ++i) {

printf("psa... %d, b4s8... %d\n", target[i], target3[i]);

}

for(int i = 0; i < vlen; ++i) {

CPPUNIT_ASSERT(target[i] == target2[i]);

CPPUNIT_ASSERT(target[i] == target3[i]);

}

void qa_16s_permute_and_scalar_add_aligned16::t1() {

const int vlen = 64;

unsigned int num_bytes = vlen << 1;

volk_environment_init();

clock_t start, end;

double total;

__VOLK_ATTR_ALIGNED(16) short target[vlen];

__VOLK_ATTR_ALIGNED(16) short target2[vlen];

__VOLK_ATTR_ALIGNED(16) short src0[vlen];

}

printf("16s_permute_and_scalar_add_aligned\n");

start = clock();

for(int i = 0; i < 100000; ++i) {

volk_16s_permute_and_scalar_add_aligned16_manual(target, src0, permute_indexes, cntl0, cntl1, cntl2, cntl3, scalars, num_bytes, "generic");

total = (double)(end-start)/(double)CLOCKS_PER_SEC;

printf("generic_time: %f\n", total);

start = clock();

for(int i = 0; i < 100000; ++i) {

volk_16s_permute_and_scalar_add_aligned16_manual(target2, src0, permute_indexes, cntl0, cntl1, cntl2, cntl3, scalars, num_bytes, "sse2");

}

end = clock();

total = (double)(end-start)/(double)CLOCKS_PER_SEC;

printf("sse2_time: %f\n", total);

for(int i = 0; i < vlen; ++i) {

//printf("generic... %d, sse2... %d\n", target[i], target2[i]);

}

for(int i = 0; i < vlen; ++i) {

CPPUNIT_ASSERT(target[i] == target2[i]);

}

}

void qa_16s_quad_max_star_aligned16::t1() {

const int vlen = 34;

__VOLK_ATTR_ALIGNED(16) short input0[vlen];

__VOLK_ATTR_ALIGNED(16) short input1[vlen];

__VOLK_ATTR_ALIGNED(16) short input2[vlen];

for(int i = 0; i < vlen; ++i) {

printf("generic... %d, sse2... %d, inputs: %d, %d, %d, %d\n", output0[i], output1[i], input0[i], input1[i], input2[i], input3[i]);

}

for(int i = 0; i < vlen; ++i) {

CPPUNIT_ASSERT_EQUAL(output0[i], output1[i]);

}

}

#else

void qa_32f_fm_detect_aligned16::t1() {

volk_environment_init();

clock_t start, end;

double total;

const int vlen = 3201;

const int ITERS = 10000;

__VOLK_ATTR_ALIGNED(16) float input0[vlen];

__VOLK_ATTR_ALIGNED(16) float output0[vlen];

__VOLK_ATTR_ALIGNED(16) float output01[vlen];

input0[i] = ((float) (rand() - (RAND_MAX/2))) / static_cast<float>((RAND_MAX/2));

}

printf("32f_fm_detect_aligned\n");

//printf("inputs: %d, %d\n", input0[i*2], input0[i*2 + 1]);

//printf("generic... %d, ssse3... %d\n", output0[i], output1[i]);

}

for(int i = 0; i < vlen; ++i) {

//printf("%d...%d\n", output0[i], output01[i]);

CPPUNIT_ASSERT_DOUBLES_EQUAL(output0[i], output01[i], fabs(output0[i]) * 1e-4);

void qa_32f_index_max_aligned16::t1(){

const int vlen = VEC_LEN;

volk_runtime_init();

volk_environment_init();

int ret;

unsigned int* target_sse;

unsigned int* target_generic;

float* src0 ;

unsigned int i_target_sse4_1;

target_sse4_1 = &i_target_sse4_1;

unsigned int i_target_sse;

target_generic = &i_target_generic;

ret = posix_memalign((void**)&src0, 16, vlen *sizeof(float));

random_floats((float*)src0, vlen);

printf("32f_index_max_aligned16\n");

clock_t start, end;

double total;

start = clock();

for(int k = 0; k < NUM_ITERS; ++k) {

volk_32f_index_max_aligned16_manual(target_generic, src0, vlen, "generic");

}

total = (double)(end-start)/(double)CLOCKS_PER_SEC;

printf("generic time: %f\n", total);

for(int k = 0; k < NUM_ITERS; ++k) {

volk_32f_index_max_aligned16_manual(target_sse, src0, vlen, "sse2");

}