La Performance de Contrefil.Incrément

Est Interlocked.Increment(ref x) plus rapide ou plus lent que x++ pour ints et longs sur les différentes plateformes?

  • Comme l'autre, ce n'est pas la même chose. Cela dit, selon msdn.microsoft.com/en-us/magazine/cc163726.aspx un Contrefil.Incrément prend un peu de 14nS (ou environ 71'000'000 par seconde), donc je ne vous inquiétez pas trop à propos de la performance
  • Interloqué.L'incrément est destiné à être utilisé dans des environnements de threads
InformationsquelleAutor SLaks | 2009-06-23
  1. 40

    Il est plus lent, car il force l'action de se produire de manière atomique et il agit comme une barrière de mémoire, en éliminant le processeur, la capacité de commander à nouveau accès à la mémoire autour de l'instruction.

    Vous devriez être en utilisant Interloqué.Incrément lorsque vous souhaitez que l'action atomique de l'état qui peuvent être partagées entre les threads - il n'est pas destiné à être un remplacement complet pour x++.

    InformationsquelleAutor Michael
  2. 16

    Dans notre expérience, les InterlockedIncrement() et al sur Windows sont assez importantes conséquences. Dans le cas d'un échantillon de cas, nous avons été en mesure d'éliminer le dispositif de verrouillage et d'utilisation ++/-- au lieu de cela. À elle seule, cette réduction de temps d'exécution à partir de 140 secondes à 110 secondes. Mon analyse est que le dispositif de verrouillage des forces de mémoire aller-retour (sinon, comment pourrait-autres carottes de le voir?). Un cache L1 de lecture/écriture est d'environ 10 cycles d'horloge, mais une mémoire en lecture/écriture, plus de 100.

    Dans ce cas d'exemple, j'ai estimé le nombre d'incrémenter/décrémenter les opérations à environ 1 milliard de dollars. Ainsi, sur un PROCESSEUR 2 ghz c'est quelque chose comme 5 secondes pour que le ++/--, et 50 secondes pour que le dispositif de verrouillage. La propagation de la différence à travers plusieurs threads, et ses près de 30 secondes.

    • Micrsoft dit: InterlockedIncrement a été mesurée en prenant 36-90 cycles msdn.microsoft.com/en-us/library/windows/desktop/...
    • 36 sons non fonctionnement, je mesure environ 120 fois pour fortement contestée opération sur un Core i7, mais peut-être que je bâclé? De toute façon, "verrouillage des forces de mémoire aller-retour (sinon, comment pourrait-autres carottes de le voir?). Un cache L1 de lecture/écriture est d'environ 10 cycles d'horloge..." - il suffit de marquer cette page comme changé et rincer à partir de la L1 à la mémoire si un autre doit voir, donc incontesté de l'opération peut être plus proche de la de 10 fin du spectre (36) plutôt que 100+....
    InformationsquelleAutor
  3. 6

    Pensez-y un instant, et vous vous rendrez compte un Increment l'appel ne peut pas être plus rapide qu'une simple application de l'opérateur d'incrémentation. Si c'était le cas, alors le compilateur de la mise en œuvre de l'opérateur d'incrémentation appellerais Increment en interne, et qu'ils auraient à effectuer la même.

    Mais, comme vous pouvez le voir en testant pour vous-même, ils n'effectuent pas le même.

    Les deux options ont des finalités différentes. Utiliser l'opérateur d'incrémentation en général. Utilisation Increment lorsque vous avez besoin de l'opération atomique et que vous êtes sûr que tous les autres utilisateurs de cette variable sont également en utilisant des opérations verrouillées. (S'ils ne sont pas tous les de coopérer, il n'a pas vraiment l'aider.)

    • Non, il ne serait pas Interloqué.Incrément ne peut pas être appelée sur un bien, tandis que le ++ opérateur. Par conséquent, ++ ne serait pas capable de l'appeler.
    • Pour être plus précis, Incrémenter prend ref int (ou long); ++ est un non-ref int (ou long)
    • Le compilateur pourrait certainement mettre en œuvre ++ par Incrément. Il ne serait pas mis en œuvre avec un simple "appel" de l'enseignement, mais il pourrait être fait à l'aide d'un temporaire introduite par le compilateur. Le point est que le compilateur utilise le jeun méthode d'incrémentation d'un numéro; si il y avait quelque chose de plus rapide, le compilateur aurait utilisé à la place.
    InformationsquelleAutor Rob Kennedy
  4. 4

    C'est plus lent. Cependant, c'est le plus performant de façon générale, je sais que pour la réalisation de la sécurité des threads sur les variables scalaires.

    • volatile est plus performant sur les scalaires, mais a l'inconvénient de nécessiter des bonnes pratiques de codage pour être bien utilisé.
    • Attention à la volatilité; certaines architectures de processeurs (x86/x64) ont la capacité de réorganiser les accès à la mémoire, que ce mémoire a été marquée, alors que la volatilité pour le compilateur.
    • Le comportement est que la spécification dit, et le compilateur est nécessaire pour mettre en œuvre les spec correctement. Un programmeur écrit pour .Net n'a jamais penser à propos de la mémoire-modèle de la sous-ISA (sauf peut-être pour la performance). Si illégales reorderings en quelque sorte de se produire, c'est un sérieux bogue du compilateur.
    • avec ++ est toujours ce n'est pas atomique / pas thread-safe, alors que les Interlocked.Increment (ou un lock et ++) est thread-safe. En outre, volatile est inutile avec soit de la validité de la thread-safe méthodes..
    • Je ne me souviens pas pourquoi j'ai écrit ce que j'ai fait il y a 10 ans, il peut y avoir eu d'autres commentaires à l'époque, qui sont maintenant supprimés. Mais le mot clé volatile doit être utilisée lorsque vous vous attendez à une variable de modifier à tout moment et les verrous ne sont pas nécessaire ou possible. Je n'utilise pas le terme "thread-safe" ici, dans mon commentaire, mais je pense que c'est dans le sens que vous ne recevrez pas les serrures, mais c'est difficile de l'utiliser. Vous ne devriez pas utiliser volatile lorsque vous voulez atomique en lecture/écriture.
    InformationsquelleAutor Drew Hoskins
  5. 3

    Il sera toujours plus lent car il doit effectuer un bus de l'unité centrale de verrouillage vs juste la mise à jour d'un registre. Cependant, les Processeurs modernes atteindre près registre de la performance il est donc négligeable, même dans le traitement en temps réel.

    • Alors que les CPU X86 effectuer un buslock pendant les opérations verrouillées, un buslock n'est pas requis par tous les CPU qui fournissent des opérations verrouillées. Certains processeurs sont capables de rendu des services qu'ils ont réservé une seule ligne de cache et peut effectuer des opérations verrouillées sur que cacheline sans buslock.
    InformationsquelleAutor Paul Alexander
  6. 2

    Ma performance test:

    volatile: 65,174,400

    de verrouillage: 62,428,600

    contrefil: 113,248,900

    TimeSpan span = TimeSpan.FromSeconds(5);

object syncRoot = new object();
long test = long.MinValue;

Do(span, "volatile", () => {

    long r = Thread.VolatileRead(ref test);

    r++;

    Thread.VolatileWrite(ref test, r);
});

Do(span, "lock", () =>
{
    lock (syncRoot)
    {
        test++;
    }
});

Do(span, "interlocked", () =>
{
    Interlocked.Increment(ref test);
});
    • Il exécute la méthode de n fois jusqu'à ce que le laps de temps a été atteint
    • Donc, attendez, plus c'est mieux dans ce cas? Pourriez-vous précisez ce que vos mesures sont?
    • N'utilisez pas VolatileRead et VolatileWrite de cette manière vous laisser ouvert à la même race condition que lock et Interlocked.Increment éviter?
    InformationsquelleAutor MastsrOfDesaster