Chiamare una funzione minore nello script da una funzione più elevata nello script

Question

Sto cercando di trovare un modo per rendere il computer fare un po 'di lavoro per me. Sto usando SIMD (SSE2 e SSE3) per calcolare il prodotto incrociato, e mi chiedevo se potesse andare più veloce. Attualmente ho il seguente:

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)
         )
      )
   );
}

Come si può vedere, ci sono quattro _mm_shuffle_ps di in là, e mi chiedevo se potessi sostituirlo con una combinazione di _mm_unpackhi_ps e _mm_unpacklo_ps che restituiscono rispettivamente a2 a3 b2 b3 e a0 a1 b0 b1 e sono leggermente più veloce.

Non ho potuto capire sulla carta, ma ho pensato di una soluzione. Che cosa succede se lasciare che il computer bruteforce i passi necessari? Basta ricorsivamente scorrere le diverse opzioni e vedere ciò che dà la risposta corretta.

ho ottenuto il lavoro con moltiplicano, restituisce questo quando voglio per tornare (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)

Molto bello, se lo dico io.

Tuttavia, quando ho voluto implementare divide mi sono imbattuto in un problema. Moltiplicare non solo deve chiamare moltiplicano, ma ha anche chiamare dividere. Va bene, così abbiamo messo divide sopra si moltiplicano. Ma divide non solo deve chiamare dividere, ha anche chiamare moltiplicare, che è più basso nello script, in modo che non esiste ancora.

Ho iniziato con un'applicazione console vuota in Visual C ++ e mettere tutto in QuadTests.cpp.

Come faccio a essere sicuro queste due funzioni possono chiamare l'un l'altro?

Grazie in anticipo.

Answer 1

Solo per confermare, il problema è che le funzioni disposte in questo modo non funzionano, perché doStuff non è dichiarato per il momento si chiama da getFoo:

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

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

    return bar * 8;
}

Per risolvere questo problema, è necessario fare una avanti dichiarazione di int doStuff(int). Spesso, questo è fatto con un file di intestazione - in entrambi i casi, non vi resta che aggiungere qualcosa di simile:

// #includes, etc. go here

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

// methods follow