__builtin_prefetch, Combien lit-il?

Je suis en train d'optimiser certains RK4 GCC C++ code à l'aide de

__builtin_prefetch

J'ai un peu de mal à essayer de comprendre comment extraire un ensemble de la classe. Je ne comprends pas comment une grande partie de la const void *addr est lu. Alors que j'ai les prochaines valeurs de from et to chargé.

for (int i = from; i < to; i++)
{
    double kv = myLinks[i].kv;
    particle* from = con[i].Pfrom;
    particle* to = con[i].Pto;
    //Prefetch values at con[i++].Pfrom & con[i].Pto;
    double pos = to->px- from->px;
    double delta = from->r + to->r - pos;
    double k1 = axcel(kv, delta, from->mass) * dt; //axcel is an inlined function
    double k2 = axcel(kv, delta + 0.5 * k1, from->mass) * dt;
    double k3 = axcel(kv, delta + 0.5 * k2, from->mass) * dt;
    double k4 = axcel(kv, delta + k3, from->mass) * dt;
    #define likely(x)       __builtin_expect((x),1)
    if (likely(!from->bc))
    {
            from->x += (( k1 + 2 * k2 + 2 * k3 + k4) / 6);
    }
}

Lien: http://www.ibm.com/developerworks/linux/library/l-gcc-hacks/

source d'informationauteur Mikhail

  1. 17

    Je pense qu'il est juste émettre une FETCH instruction machine, qui, fondamentalement, récupère une ligne de cache, dont la taille est de processeur spécifique.

    Et vous pouvez utiliser __builtin_prefetch (con[i+3].Pfrom) par exemple. Par ma (petite) expérience, dans une boucle de ce genre, il est préférable de prélecture de plusieurs éléments à l'avance.

    Ne pas utiliser __builtin_prefetch trop souvent (c'est à dire ne pas mettre beaucoup d'entre eux à l'intérieur d'une boucle). Mesurer le gain de performance si vous avez besoin d'eux, et d'utiliser l'optimisation GCC (au moins -O2). Si vous êtes très chanceux, manuel __builtin_prefetch pourrait augmenter les performances de votre boucle de 10 ou de 20% (mais il pourrait aussi mal).

    Si une telle boucle est crucial pour vous, vous pourriez envisager de l'exécution sur Gpu avec OpenCL ou CUDA (mais qui nécessite recoder certaines routines en OpenCL ou CUDA de la langue, et l'accorder à votre matériel).

    Aussi utiliser une version récente de GCC compilateur (la dernière version est 4.6.2) parce qu'il fait beaucoup de progrès dans ces domaines.

    (ajouté en janvier 2018:)

    À la fois le matériel (processeurs) et les compilateurs ont fait beaucoup de progrès en matière de caches, il semble donc que l'utilisation de __builtin_prefetch est moins utile aujourd'hui (en 2018). Assurez-vous de benchmarck.

  2. 10

    Il lit une ligne de cache. Ligne de Cache taille peut varier, mais il est le plus susceptible d'être de 64 octets sur les Processeurs modernes. Si vous avez besoin de lire plusieurs lignes de cache, découvrez prefetch_range.