Llamar a una función menor en el guión de una función mayor en el guión

Question

Estoy tratando de encontrar una manera de hacer que el ordenador haga algún trabajo para mí. Estoy usando SIMD (SSE2 y SSE3) para calcular el producto vectorial, y me preguntaba si podría ir más rápido. Actualmente tengo el siguiente:

const int maskShuffleCross1 = _MM_SHUFFLE(3,0,2,1); // y z x
const int maskShuffleCross2 = _MM_SHUFFLE(3,1,0,2); // z x y

__m128 QuadCrossProduct(__m128* quadA, __m128* quadB)
{
   // (y * other.z) - (z * other.y)
   // (z * other.x) - (x * other.z)
   // (x * other.y) - (y * other.x)

   return
   (
      _mm_sub_ps
      (
         _mm_mul_ps
         (
            _mm_shuffle_ps(*quadA, *quadA, maskShuffleCross1),
            _mm_shuffle_ps(*quadB, *quadB, maskShuffleCross2)
         ),
         _mm_mul_ps
         (
            _mm_shuffle_ps(*quadA, *quadA, maskShuffleCross2),
            _mm_shuffle_ps(*quadB, *quadB, maskShuffleCross1)
         )
      )
   );
}

Como se puede ver, hay cuatro _mm_shuffle_ps está ahí, y me preguntaba si podría reemplazarlos con una combinación de _mm_unpackhi_ps y _mm_unpacklo_ps cuales a2 a3 b2 b3 retorno y a0 a1 b0 b1, respectivamente, y son un poco más rápido.

No podía entenderlo en el papel, pero yo pensado en una solución. ¿Qué pasa si deja que requiere el equipo de fuerza bruta los pasos? Sólo el paso de forma recursiva a través de las diferentes opciones y ver lo que le da la respuesta correcta.

Tengo que funcione con multiplican, devuelve esto cuando quiero que vuelva (3, 12, 27, 0):

startA = _mm_set_ps(1.00, 2.00, 3.00, 0.00);
startB = _mm_set_ps(3.00, 3.00, 3.00, 0.00);
result0 = _mm_mul_ps(startA, startB);
// (3.00, 6.00, 9.00, 0.00)
result1 = _mm_mul_ps(startA, result0);
// (3.00, 12.00, 27.00, 0.00)

Muy bonito, si lo digo yo.

Sin embargo, cuando quería poner en práctica brecha que tropezó con un problema. Multiplicar no sólo tiene que llamar multiplican, sino que también tiene que llamar a dividir. Vale, así que pusimos anteriormente brecha se multiplican. Pero brecha no sólo tiene que llamar a dividir, que también tiene que llamar multiplican, lo que es más baja en la secuencia de comandos, por lo que todavía no existe.

Me comenzó con una aplicación vacía de la consola en Visual C ++ y poner todo en QuadTests.cpp.

¿Cómo me aseguro de que estas dos funciones se pueden llamar a los demás?

Gracias de antemano.

Answer 1

Sólo para confirmar, el problema es que las funciones dispuestas como esto no trabajo, porque doStuff no se ha declarado en el momento en el que lo llamó getFoo:

int getFoo(int bar) {
    doStuff(bar + 1);
}

int doStuff(bar) {
    if (bar == 2) {
        return getFoo(bar);
    }

    return bar * 8;
}

Para solucionar este problema, es necesario hacer una declaración adelantada de int doStuff(int). A menudo, esto se hace con un archivo de cabecera - de cualquier manera, sólo tiene que añadir algo como esto:

// #includes, etc. go here

int doStuff(int);
int getFoo(int);

// methods follow