Appeler une fonction plus faible dans le script d'une fonction plus élevée dans le script

Question

Je suis en train de trouver un moyen de rendre l'ordinateur faire un travail pour moi. J'utilise SIMD (SSE2 et SSE3) pour calculer le produit croisé, et je me demandais si elle pouvait aller plus vite. À l'heure actuelle, je donne les résultats suivants:

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

Comme vous pouvez le voir, il y a quatre _mm_shuffle_ps est là, et je me suis demandé si je pouvais les remplacer par une combinaison de _mm_unpackhi_ps et _mm_unpacklo_ps qui reviennent a2 a3 b2 b3 et a0 a1 b0 b1 respectivement, et sont un peu plus rapide.

Je ne pouvais pas le comprendre sur le papier, mais je pensais que d'une solution. Que faire si laissez l'ordinateur bruteforce les étapes nécessaires? Il suffit de l'étape récursive à travers les différentes options et voir ce qui donne la bonne réponse.

Je l'ai travailler avec se multiplient, il retourne quand je veux revenir (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)

Très bien, si je le dis moi-même.

Cependant, quand je voulais mettre en œuvre diviser je suis tombé sur un problème. Multiplier n'a pas seulement d'appeler multiplier, il doit également appeler diviser. D'accord, nous mettons au-dessus de fracture se multiplient. Mais fracture n'a pas seulement d'appeler diviser, il doit également appeler multiplier, ce qui est plus faible dans le script, donc il n'existe pas encore.

J'ai commencé avec une application console vide dans Visual C ++ et tout mettre en QuadTests.cpp.

Comment puis-je faire en sorte que ces deux fonctions peuvent appeler l'autre?

Merci d'avance.

Answer 1

Juste pour confirmer, votre problème est que les fonctions disposées comme celui-ci ne fonctionnent pas, parce que doStuff n'est pas déclarée au moment où vous l'appelez de getFoo:

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

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

    return bar * 8;
}

Pour résoudre ce problème, vous devez faire un avant déclaration de int doStuff(int). Souvent, cela se fait avec un fichier d'en-tête - soit, vous avez juste besoin d'ajouter quelque chose comme ceci:

// #includes, etc. go here

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

// methods follow